dont add detector id for .trim

Merge branch 'my3regs' into developer
fixed compile defs for moench zmq
2025-06-13 21:37:13 +02:00 · 2021-04-27 08:28:05 +02:00 · 2021-04-26 08:39:46 +02:00 · 2021-04-22 08:29:15 +02:00 · 2021-04-21 17:25:51 +02:00 · 2021-04-21 15:40:51 +02:00
78 changed files with 5286 additions and 720 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.12)
 project(slsDetectorPackage)
-set(PROJECT_VERSION 5.0.0)
+set(PROJECT_VERSION 5.1.0)
 include(CheckIPOSupported)
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")

@ -157,8 +157,37 @@ set(CMAKE_INSTALL_RPATH $ORIGIN)
 set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)


+set(ZeroMQ_HINT "" CACHE STRING "Hint where ZeroMQ could be found")
+#Adapted from: https://github.com/zeromq/cppzmq/
+if (NOT TARGET libzmq)
+    if(ZeroMQ_HINT)
+        message(STATUS "Looking for ZeroMQ in: ${ZeroMQ_HINT}")
+        find_package(ZeroMQ 4 
+            NO_DEFAULT_PATH
+            HINTS ${ZeroMQ_DIR}
+        )
+    else()
+        find_package(ZeroMQ 4 QUIET)
+    endif()
+    

-find_package(ZeroMQ 4 REQUIRED)
+
+  # libzmq autotools install: fallback to pkg-config
+  if(NOT ZeroMQ_FOUND)
+    message(STATUS "CMake libzmq package not found, trying again with pkg-config (normal install of zeromq)")
+    list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/libzmq-pkg-config)
+    find_package(ZeroMQ 4 REQUIRED)
+  endif()
+
+  # TODO "REQUIRED" above should already cause a fatal failure if not found, but this doesn't seem to work
+  if(NOT ZeroMQ_FOUND)
+    message(FATAL_ERROR "ZeroMQ was not found, neither as a CMake package nor via pkg-config")
+  endif()
+
+  if (ZeroMQ_FOUND AND NOT TARGET libzmq)
+    message(FATAL_ERROR "ZeroMQ version not supported!")
+  endif()
+endif()

 if (SLS_USE_TESTS)
    enable_testing()
--- a/RELEASE.txt
+++ b/RELEASE.txt
@ -1,14 +1,13 @@
-SLS Detector Package 5.1.0 released on xx.xx.2020 (Minor Release)
+SLS Detector Package 5.X.X released on XX.XX.2021 (Minor Release)
 ===================================================================

-This document describes the differences between 5.1.0 and 5.x.x releases.   
+This document describes the differences between X and Y releases.   



    CONTENTS
    --------
-    1.  Topics Concerning
-    2.  New Features
+    1.  New Features
    2.  Resolved Issues
    3.  Known Issues
    4.  Firmware Requirements
@ -16,58 +15,15 @@ This document describes the differences between 5.1.0 and 5.x.x releases.



-1. Topics Concerning
-====================

-    - potentital memory leak in receiver
-    - scanParameters in Python
-    - cmk.sh refactored
-    - m3 settings and threshold
-
-
-2. New Features
+1. New Features
 ===============

-    Client
-    ------
-
-    1. Aded settings and threshold features for Mythen3.
-    2. Internal modification of acquire for Mythen3.
-    3. Added getMaster functio for M3
-
-
-    Mythen3 server
-    -----------------
-
-    1. Setting timing to auto, sets timing to trigger for slaves
-    
-
-3. Resolved Issues
-==================
-
-
-    Receiver
-    --------
-
-    1.  Current code only calls Implementation::setDetectorType from constructor, 
-	    but potential memory leak if called out of constructor context. Fixed.
-
-    Client
-    ------
-
-    1.  Fixed missing scanParameters class in Python 
-
-    2.  cmk.sh refactored to have better option handling
-
-
-
-
+    Setting Mythen3 gain from command line

 4. Firmware Requirements
 ========================
-        
-    No updates from 5.0.0
-
+    


 5. Known Issues
--- a/cmake/FindZeroMQ.cmake
+++ b/cmake/FindZeroMQ.cmake
@ -1,112 +0,0 @@
-
-# This file is originally from https://github.com/zeromq/azmq and distributed 
-# under Boost Software Lincese 1.0
-# Boost Software License - Version 1.0 - August 17th, 2003
-
-# Permission is hereby granted, free of charge, to any person or organization
-# obtaining a copy of the software and accompanying documentation covered by
-# this license (the "Software") to use, reproduce, display, distribute,
-# execute, and transmit the Software, and to prepare derivative works of the
-# Software, and to permit third-parties to whom the Software is furnished to
-# do so, all subject to the following:
-
-# The copyright notices in the Software and this entire statement, including
-# the above license grant, this restriction and the following disclaimer,
-# must be included in all copies of the Software, in whole or in part, and
-# all derivative works of the Software, unless such copies or derivative
-# works are solely in the form of machine-executable object code generated by
-# a source language processor.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-# SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-# FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-# --------------------------------------------------------------------------------
-
-# Find ZeroMQ Headers/Libs
-
-# Variables
-# ZMQ_ROOT - set this to a location where ZeroMQ may be found
-#
-# ZeroMQ_FOUND - True of ZeroMQ found
-# ZeroMQ_INCLUDE_DIRS - Location of ZeroMQ includes
-# ZeroMQ_LIBRARIES - ZeroMQ libraries
-
-include(FindPackageHandleStandardArgs)
-
-if (NOT ZMQ_ROOT)
-    set(ZMQ_ROOT "$ENV{ZMQ_ROOT}")
-endif()
-
-if (NOT ZMQ_ROOT)
-    find_path(_ZeroMQ_ROOT NAMES include/zmq.h)
-else()
-    set(_ZeroMQ_ROOT "${ZMQ_ROOT}")
-endif()
-
-find_path(ZeroMQ_INCLUDE_DIRS NAMES zmq.h HINTS ${_ZeroMQ_ROOT}/include)
-
-if (ZeroMQ_INCLUDE_DIRS)
-    set(_ZeroMQ_H ${ZeroMQ_INCLUDE_DIRS}/zmq.h)
-
-    function(_zmqver_EXTRACT _ZeroMQ_VER_COMPONENT _ZeroMQ_VER_OUTPUT)
-        set(CMAKE_MATCH_1 "0")
-        set(_ZeroMQ_expr "^[ \\t]*#define[ \\t]+${_ZeroMQ_VER_COMPONENT}[ \\t]+([0-9]+)$")
-        file(STRINGS "${_ZeroMQ_H}" _ZeroMQ_ver REGEX "${_ZeroMQ_expr}")
-        string(REGEX MATCH "${_ZeroMQ_expr}" ZeroMQ_ver "${_ZeroMQ_ver}")
-        set(${_ZeroMQ_VER_OUTPUT} "${CMAKE_MATCH_1}" PARENT_SCOPE)
-    endfunction()
-
-    _zmqver_EXTRACT("ZMQ_VERSION_MAJOR" ZeroMQ_VERSION_MAJOR)
-    _zmqver_EXTRACT("ZMQ_VERSION_MINOR" ZeroMQ_VERSION_MINOR)
-    _zmqver_EXTRACT("ZMQ_VERSION_PATCH" ZeroMQ_VERSION_PATCH)
-
-    message(STATUS "ZeroMQ version: ${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}.${ZeroMQ_VERSION_PATCH}")
-
-    # We should provide version to find_package_handle_standard_args in the same format as it was requested,
-    # otherwise it can't check whether version matches exactly.
-    if (ZeroMQ_FIND_VERSION_COUNT GREATER 2)
-        set(ZeroMQ_VERSION "${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}.${ZeroMQ_VERSION_PATCH}")
-    else()
-        # User has requested ZeroMQ version without patch part => user is not interested in specific patch =>
-        # any patch should be an exact match.
-        set(ZeroMQ_VERSION "${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}")
-    endif()
-
-    if (NOT ${CMAKE_CXX_PLATFORM_ID} STREQUAL "Windows")
-        find_library(ZeroMQ_LIBRARIES NAMES zmq HINTS ${_ZeroMQ_ROOT}/lib)
-    else()
-        find_library(
-            ZeroMQ_LIBRARY_RELEASE
-            NAMES
-                libzmq
-                "libzmq-${CMAKE_VS_PLATFORM_TOOLSET}-mt-${ZeroMQ_VERSION_MAJOR}_${ZeroMQ_VERSION_MINOR}_${ZeroMQ_VERSION_PATCH}"
-            HINTS
-                ${_ZeroMQ_ROOT}/lib
-            )
-
-        find_library(
-            ZeroMQ_LIBRARY_DEBUG
-            NAMES
-                libzmq_d
-                "libzmq-${CMAKE_VS_PLATFORM_TOOLSET}-mt-gd-${ZeroMQ_VERSION_MAJOR}_${ZeroMQ_VERSION_MINOR}_${ZeroMQ_VERSION_PATCH}"
-            HINTS
-                ${_ZeroMQ_ROOT}/lib)
-
-        # On Windows we have to use corresponding version (i.e. Release or Debug) of ZeroMQ because of `errno` CRT global variable
-        # See more at http://www.drdobbs.com/avoiding-the-visual-c-runtime-library/184416623
-        set(ZeroMQ_LIBRARIES optimized "${ZeroMQ_LIBRARY_RELEASE}" debug "${ZeroMQ_LIBRARY_DEBUG}")
-    endif()
-endif()
-
-find_package_handle_standard_args(ZeroMQ FOUND_VAR ZeroMQ_FOUND
-    REQUIRED_VARS ZeroMQ_INCLUDE_DIRS ZeroMQ_LIBRARIES
-    VERSION_VAR ZeroMQ_VERSION)
-
-if (ZeroMQ_FOUND)
-    mark_as_advanced(ZeroMQ_INCLUDE_DIRS ZeroMQ_LIBRARIES ZeroMQ_VERSION
-        ZeroMQ_VERSION_MAJOR ZeroMQ_VERSION_MINOR ZeroMQ_VERSION_PATCH)
-endif()
--- a/cmake/package_config.cmake
+++ b/cmake/package_config.cmake
@ -25,6 +25,12 @@ install(FILES
  DESTINATION ${CMAKE_INSTALL_DIR}
 )

+install(FILES
+  "${CMAKE_SOURCE_DIR}/libzmq-pkg-config/FindZeroMQ.cmake"
+  COMPONENT devel
+  DESTINATION ${CMAKE_INSTALL_DIR}/libzmq-pkg-config
+)
+
 if (PROJECT_LIBRARIES OR PROJECT_STATIC_LIBRARIES)
  install(
    EXPORT "${TARGETS_EXPORT_NAME}"
--- a/cmake/project-config.cmake.in
+++ b/cmake/project-config.cmake.in
@ -12,8 +12,21 @@ include(CMakeFindDependencyMacro)

 set(SLS_USE_HDF5 "@SLS_USE_HDF5@")

-# Add optional dependencies here
+
+find_package(ZeroMQ 4 QUIET)
+# libzmq autotools install: fallback to pkg-config
+if(NOT ZeroMQ_FOUND)
+    list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/libzmq-pkg-config)
+    find_package(ZeroMQ 4 REQUIRED)
+endif()
+
+if(NOT ZeroMQ_FOUND)
+    message(FATAL_ERROR "ZeroMQ was NOT found!")
+endif()
+
 find_dependency(Threads)
+
+# Add optional dependencies here
 if (SLS_USE_HDF5)
    find_dependency(HDF5)
 endif ()
--- a/conda-recepie/build.sh
+++ b/conda-recepie/build.sh
@ -13,8 +13,9 @@ cmake .. \
      -DCMAKE_BUILD_TYPE=Release \
      -DSLS_USE_HDF5=OFF\
     
-
-cmake --build . -- -j10
+NCORES=$(getconf _NPROCESSORS_ONLN)
+echo "Building using: ${NCORES} cores"
+cmake --build . -- -j${NCORES}
 cmake --build . --target install

-CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
+CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
--- a/conda-recepie/copy_gui.sh
+++ b/conda-recepie/copy_gui.sh
@ -1,3 +1,3 @@
 #Copy the GUI 
-mkdir $PREFIX/bin
-cp build/bin/slsDetectorGui $PREFIX/bin/.
+mkdir -p $PREFIX/bin
+cp build/install/bin/slsDetectorGui $PREFIX/bin/.
--- a/conda-recepie/copy_lib.sh
+++ b/conda-recepie/copy_lib.sh
@ -1,6 +1,6 @@

-mkdir $PREFIX/lib
-mkdir $PREFIX/bin
+mkdir -p $PREFIX/lib
+mkdir -p $PREFIX/bin
 mkdir -p $PREFIX/include/sls
 # mkdir $PREFIX/include/slsDetectorPackage

--- a/conda-recepie/meta.yaml
+++ b/conda-recepie/meta.yaml
@ -59,6 +59,16 @@ outputs:
    script: copy_lib.sh

    requirements:
+      build:
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - libstdcxx-ng
+        - libgcc-ng
+        - zeromq
+
+      host:
+        - zeromq
+
      run: 
        - libstdcxx-ng
        - libgcc-ng
@ -78,6 +88,8 @@ outputs:

      host:
        - python
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+

      run:
        - libstdcxx-ng
@ -94,6 +106,13 @@ outputs:
  - name: slsdetgui
    script: copy_gui.sh
    requirements:
+
+      build:
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+        - qwt 6.*
+
      run:
        - {{ pin_subpackage('slsdetlib', exact=True) }}
        - qwt 6.*
--- a/libzmq-pkg-config/FindZeroMQ.cmake
+++ b/libzmq-pkg-config/FindZeroMQ.cmake
@ -0,0 +1,27 @@
+#From: https://github.com/zeromq/cppzmq/
+set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH ON)
+find_package(PkgConfig)
+pkg_check_modules(PC_LIBZMQ QUIET libzmq)
+
+set(ZeroMQ_VERSION ${PC_LIBZMQ_VERSION})
+find_library(ZeroMQ_LIBRARY NAMES libzmq.so libzmq.dylib libzmq.dll
+             PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
+find_library(ZeroMQ_STATIC_LIBRARY NAMES libzmq-static.a libzmq.a libzmq.dll.a
+             PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
+
+if(ZeroMQ_LIBRARY OR ZeroMQ_STATIC_LIBRARY)
+    set(ZeroMQ_FOUND ON)
+endif()
+
+if (TARGET libzmq)
+    # avoid errors defining targets twice
+    return()
+endif()
+
+add_library(libzmq SHARED IMPORTED)
+set_property(TARGET libzmq PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
+set_property(TARGET libzmq PROPERTY IMPORTED_LOCATION ${ZeroMQ_LIBRARY})
+
+add_library(libzmq-static STATIC IMPORTED ${PC_LIBZMQ_INCLUDE_DIRS})
+set_property(TARGET libzmq-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
+set_property(TARGET libzmq-static PROPERTY IMPORTED_LOCATION ${ZeroMQ_STATIC_LIBRARY})
--- a/python/scripts/compile_servers.py
+++ b/python/scripts/compile_servers.py
@ -0,0 +1,80 @@
+import subprocess
+import os
+import sys
+from pathlib import Path
+import shutil as sh
+from argparse import ArgumentParser
+
+class color:
+    HEADER = "\033[95m"
+    BLUE = "\033[94m"
+    CYAN = "\033[96m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    RED = "\033[91m"
+    ENDC = "\033[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+    MAGENTA = "\033[35m"
+
+    @staticmethod
+    def red(s):
+        return f"{color.RED}{s}{color.ENDC}"
+
+    @staticmethod
+    def green(s):
+        return f"{color.GREEN}{s}{color.ENDC}"
+
+def add_to_path():
+    paths = [
+        "/opt/uClinux/bfin-uclinux/bin",
+        "/opt/nios2-gcc/bin",
+        "/opt/eldk-5.1/powerpc-4xx-softfloat/sysroots/i686-eldk-linux/usr/bin/ppc405-linux",
+    ]
+    os.environ["PATH"] += os.pathsep + os.pathsep.join(paths)
+
+
+def rc_to_string(rc):
+    if rc == 0:
+        return color.green("OK")
+    else:
+        return color.red("FAIL")
+
+
+
+parser = ArgumentParser()
+parser.add_argument('-t', '--tag', help = 'Tag added to server file name', default='developer')
+parser.add_argument('-g', '--git', help='Add new servers to the git repo', action="store_true")
+args = parser.parse_args()
+
+
+servers = [
+#     "eigerDetectorServer",
+#     "jungfrauDetectorServer",
+      "mythen3DetectorServer",
+#     "gotthard2DetectorServer",
+#     "gotthardDetectorServer",
+#     "ctbDetectorServer",
+#     "moenchDetectorServer",
+]
+
+
+server_root = Path("../../slsDetectorServers/").resolve()
+
+add_to_path()
+for server in servers:
+    bin_name = f"{server}_{args.tag}"
+    path = server_root / server
+    print(f"{bin_name} - ", end="")
+    os.chdir(path)
+    try: 
+        sh.rmtree(path/'bin')
+    except FileNotFoundError:
+        pass
+    p = subprocess.run(["make"], stdout=subprocess.DEVNULL)
+    print(rc_to_string(p.returncode))
+    if p.returncode == 0:
+        sh.move(f"bin/{server}", f"bin/{bin_name}")
+        if args.git:
+            print("Adding to git")
+            subprocess.run(['git', 'add', 'bin', '-f'])
--- a/python/scripts/generate_enums.py
+++ b/python/scripts/generate_enums.py
@ -11,6 +11,8 @@ import subprocess

 from parse import remove_comments

+allow_bitwise_op = ["M3_GainCaps"]
+
 def single_line_enum(line):
    sub = line[line.find('{')+1:line.find('}')]
    return sub.strip().split(',')
@ -49,7 +51,11 @@ def extract_enums(lines):
 def generate_enum_string(enums):
    data = []
    for key, value in enums.items():
-        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}")\n')
+        if key in allow_bitwise_op:
+            tag=", py::arithmetic()"
+        else:
+            tag=""
+        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}"{tag})\n')
        for v in value:
            data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\n')
        data.append('.export_values();\n\n')
--- a/python/setup.py
+++ b/python/setup.py
@ -2,11 +2,12 @@
 Setup file for slsdet
 Build upon the pybind11 example found here: https://github.com/pybind/python_example
 """
-from setuptools import setup, Extension, find_packages
-from setuptools.command.build_ext import build_ext
-import sys
-import setuptools
+
 import os
+import sys
+sys.path.append('../libs/pybind11')
+from setuptools import setup, find_packages
+from pybind11.setup_helpers import Pybind11Extension, build_ext

 __version__ = os.environ.get('GIT_DESCRIBE_TAG', 'developer')

@ -19,109 +20,29 @@ def get_conda_path():
    return os.environ['CONDA_PREFIX']


-# class get_pybind_include(object):
-#     """Helper class to determine the pybind11 include path
-#     The purpose of this class is to postpone importing pybind11
-#     until it is actually installed, so that the ``get_include()``
-#     method can be invoked. """
-
-#     def __init__(self, user=False):
-#         self.user = user
-
-#     def __str__(self):
-#         import pybind11
-#         return pybind11.get_include(self.user)
-
-
+#TODO migrate to CMake build? 
 ext_modules = [
-    Extension(
+    Pybind11Extension(
        '_slsdet',
        ['src/main.cpp',
        'src/enums.cpp',
        'src/detector.cpp',
-        'src/network.cpp'],
+        'src/network.cpp',
+        'src/pattern.cpp',
+        'src/scan.cpp',],
        include_dirs=[
-            # Path to pybind11 headers
-            # get_pybind_include(),
-            # get_pybind_include(user=True),
            os.path.join('../libs/pybind11/include'),
            os.path.join(get_conda_path(), 'include'),

        ],
-        libraries=['SlsDetector', 'SlsReceiver', 'zmq'],
+        libraries=['SlsDetector', 'SlsSupport', 'SlsReceiver', 'zmq'],
        library_dirs=[
            os.path.join(get_conda_path(), 'lib'),
-            os.path.join(get_conda_path(), 'bin'),
        ],
-
        language='c++'
    ),
 ]

-
-# As of Python 3.6, CCompiler has a `has_flag` method.
-# cf http://bugs.python.org/issue26689
-def has_flag(compiler, flagname):
-    """Return a boolean indicating whether a flag name is supported on
-    the specified compiler.
-    """
-    import tempfile
-    with tempfile.NamedTemporaryFile('w', suffix='.cpp') as f:
-        f.write('int main (int argc, char **argv) { return 0; }')
-        try:
-            compiler.compile([f.name], extra_postargs=[flagname])
-        except setuptools.distutils.errors.CompileError:
-            return False
-    return True
-
-
-def cpp_flag(compiler):
-    """Return the -std=c++[11/14] compiler flag.
-    The c++14 is prefered over c++11 (when it is available).
-    """
-    if has_flag(compiler, '-std=c++14'):
-        return '-std=c++14'
-    elif has_flag(compiler, '-std=c++11'):
-        return '-std=c++11'
-    else:
-        raise RuntimeError('Unsupported compiler -- at least C++11 support '
-                           'is needed!')
-
-
-class BuildExt(build_ext):
-    """A custom build extension for adding compiler-specific options."""
-    c_opts = {
-        'msvc': ['/EHsc'],
-        'unix': [],
-    }
-
-    if sys.platform == 'darwin':
-        c_opts['unix'] += ['-stdlib=libc++', '-mmacosx-version-min=10.7']
-
-    def build_extensions(self):
-        ct = self.compiler.compiler_type
-        opts = self.c_opts.get(ct, [])
-        if ct == 'unix':
-            opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
-            opts.append(cpp_flag(self.compiler))
-            if has_flag(self.compiler, '-fvisibility=hidden'):
-                opts.append('-fvisibility=hidden')
-        elif ct == 'msvc':
-            opts.append('/DVERSION_INFO=\\"%s\\"' % self.distribution.get_version())
-        for ext in self.extensions:
-            ext.extra_compile_args = opts
-
-        print('**************************************************')
-        print(ct)
-        print(opts)
-        print('**************************************************')
-        build_ext.build_extensions(self)
-        
-
-
-def get_shared_lib():
-    return [f for f in os.listdir('.') if '_slsdet' in f]
-
 setup(
    name='slsdet',
    version=__version__,
@ -132,6 +53,6 @@ setup(
    long_description='',
    packages=find_packages(exclude=['contrib', 'docs', 'tests']),
    ext_modules=ext_modules,
-    cmdclass={'build_ext': BuildExt},
+    cmdclass={"build_ext": build_ext},
    zip_safe=False,
 )
--- a/python/slsdet/enums.py
+++ b/python/slsdet/enums.py
@ -14,4 +14,5 @@ clockIndex = _slsdet.slsDetectorDefs.clockIndex
 readoutMode = _slsdet.slsDetectorDefs.readoutMode
 masterFlags = _slsdet.slsDetectorDefs.masterFlags
 burstMode = _slsdet.slsDetectorDefs.burstMode
-timingSourceType = _slsdet.slsDetectorDefs.timingSourceType
+timingSourceType = _slsdet.slsDetectorDefs.timingSourceType
+M3_GainCaps = _slsdet.slsDetectorDefs.M3_GainCaps
--- a/python/src/detector.cpp
+++ b/python/src/detector.cpp
@ -1136,6 +1136,16 @@ void init_det(py::module &m) {
             (Result<bool>(Detector::*)(sls::Positions) const) &
                 Detector::getMaster,
             py::arg() = Positions{})
+        .def("getChipStatusRegister",
+             (Result<int>(Detector::*)(sls::Positions) const) &
+                 Detector::getChipStatusRegister,
+             py::arg() = Positions{})
+        .def("setGainCaps",
+             (void (Detector::*)(int, sls::Positions)) & Detector::setGainCaps,
+             py::arg(), py::arg() = Positions{})
+        .def("getGainCaps",
+             (Result<int>(Detector::*)(sls::Positions)) & Detector::getGainCaps,
+             py::arg() = Positions{})
        .def("getNumberOfAnalogSamples",
             (Result<int>(Detector::*)(sls::Positions) const) &
                 Detector::getNumberOfAnalogSamples,
--- a/python/src/enums.cpp
+++ b/python/src/enums.cpp
@ -277,4 +277,14 @@ void init_enums(py::module &m) {
        .value("TIMING_EXTERNAL",
               slsDetectorDefs::timingSourceType::TIMING_EXTERNAL)
        .export_values();
+
+    py::enum_<slsDetectorDefs::M3_GainCaps>(Defs, "M3_GainCaps",
+                                            py::arithmetic())
+        .value("M3_C10pre", slsDetectorDefs::M3_GainCaps::M3_C10pre)
+        .value("M3_C15sh", slsDetectorDefs::M3_GainCaps::M3_C15sh)
+        .value("M3_C30sh", slsDetectorDefs::M3_GainCaps::M3_C30sh)
+        .value("M3_C50sh", slsDetectorDefs::M3_GainCaps::M3_C50sh)
+        .value("M3_C225ACsh", slsDetectorDefs::M3_GainCaps::M3_C225ACsh)
+        .value("M3_C15pre", slsDetectorDefs::M3_GainCaps::M3_C15pre)
+        .export_values();
 }
--- a/slsDetectorCalibration/circularFifo.h
+++ b/slsDetectorCalibration/circularFifo.h
@ -0,0 +1,156 @@
+#pragma once
+/* CircularFifo.h 
+* Code & platform dependent issues with it was originally
+* published at http://www.kjellkod.cc/threadsafecircularqueue
+* 2009-11-02
+* @author Kjell Hedstr<74>m, hedstrom@kjellkod.cc
+* modified by the sls detetor group
+* */
+
+//#include "sls_receiver_defs.h"
+#include <semaphore.h>
+#include <vector>
+#include <iostream>
+
+typedef  double double32_t;
+typedef  float float32_t;
+typedef  int int32_t;
+
+
+
+/** Circular Fifo (a.k.a. Circular Buffer)
+* Thread safe for one reader, and one writer */
+template<typename Element>
+class CircularFifo {
+public:
+
+   CircularFifo(unsigned int Size) : tail(0), head(0){
+	   Capacity = Size + 1;
+	   array.resize(Capacity);
+	   sem_init(&data_mutex,0,0);
+	   sem_init(&free_mutex,0,Size);
+   }
+   virtual ~CircularFifo() {
+       sem_destroy(&data_mutex);
+	   sem_destroy(&free_mutex);
+   }
+
+   bool push(Element*& item_, bool no_block=false);
+   bool pop(Element*& item_, bool no_block=false);
+
+   bool isEmpty() const;
+   bool isFull() const;
+
+   int getDataValue() const;
+   int getFreeValue() const;
+
+private:
+   std::vector <Element*> array;
+   unsigned int tail; // input index
+   unsigned int head; // output index
+   unsigned int Capacity;
+   mutable sem_t data_mutex;
+   mutable sem_t free_mutex;
+   unsigned int increment(unsigned int idx_) const;
+};
+
+template<typename Element>
+int CircularFifo<Element>::getDataValue() const
+{
+   int value;
+   sem_getvalue(&data_mutex, &value);
+   return value;
+}
+
+template<typename Element>
+int CircularFifo<Element>::getFreeValue() const
+{
+    int value;
+    sem_getvalue(&free_mutex, &value);
+    return value;
+}
+
+
+/** Producer only: Adds item to the circular queue.
+* If queue is full at 'push' operation no update/overwrite
+* will happen, it is up to the caller to handle this case
+*
+* \param item_ copy by reference the input item
+* \param no_block if true, return immediately if fifo is full
+* \return whether operation was successful or not */
+template<typename Element>
+bool CircularFifo<Element>::push(Element*& item_, bool no_block)
+{
+    // check for fifo full
+    if (no_block && isFull())
+        return false;
+
+    sem_wait(&free_mutex);
+    array[tail] = item_;
+    tail = increment(tail);
+    sem_post(&data_mutex);
+    return true;
+}
+
+/** Consumer only: Removes and returns item from the queue
+* If queue is empty at 'pop' operation no retrieve will happen
+* It is up to the caller to handle this case
+*
+* \param item_ return by reference the wanted item
+* \param no_block if true, return immediately if fifo is full
+* \return whether operation was successful or not */
+template<typename Element>
+bool CircularFifo<Element>::pop(Element*& item_, bool no_block)
+{
+    // check for fifo empty
+    if (no_block && isEmpty())
+        return false;
+
+   sem_wait(&data_mutex);
+   item_ = array[head];
+   head = increment(head);
+   sem_post(&free_mutex);
+   return true;
+}
+
+/** Useful for testinng and Consumer check of status
+  * Remember that the 'empty' status can change quickly
+  * as the Procuder adds more items.
+  *
+  * \return true if circular buffer is empty */
+template<typename Element>
+bool CircularFifo<Element>::isEmpty() const
+{
+    return (getDataValue() == 0);
+}
+
+/** Useful for testing and Producer check of status
+  * Remember that the 'full' status can change quickly
+  * as the Consumer catches up.
+  *
+  * \return true if circular buffer is full.  */
+template<typename Element>
+bool CircularFifo<Element>::isFull() const
+{
+    return (getFreeValue() == 0);
+}
+
+/** Increment helper function for index of the circular queue
+* index is inremented or wrapped
+*
+*  \param idx_ the index to the incremented/wrapped
+*  \return new value for the index */
+template<typename Element>
+unsigned int CircularFifo<Element>::increment(unsigned int idx_) const
+{
+   // increment or wrap
+   // =================
+   //    index++;
+   //    if(index == array.lenght) -> index = 0;
+   //
+   //or as written below:
+   //    index = (index+1) % array.length
+   idx_ = (idx_+1) % Capacity;
+   return idx_;
+}
+
--- a/slsDetectorCalibration/dataStructures/jungfrauHighZSingleChipData.h
+++ b/slsDetectorCalibration/dataStructures/jungfrauHighZSingleChipData.h
@ -0,0 +1,238 @@
+#ifndef JUNGFRAUHIGHZSINGLECHIPDATA_H
+#define  JUNGFRAUHIGHZSINGLECHIPDATA_H
+#include "slsDetectorData.h"
+
+//#define VERSION_V2
+    /**
+        @short  structure for a Detector Packet or Image Header
+        @li frameNumber is the frame number
+        @li expLength is the subframe number (32 bit eiger) or real time exposure time in 100ns (others)
+        @li packetNumber is the packet number
+        @li bunchId is the bunch id from beamline
+        @li timestamp is the time stamp with 10 MHz clock
+        @li modId is the unique module id (unique even for left, right, top, bottom)
+        @li xCoord is the x coordinate in the complete detector system
+        @li yCoord is the y coordinate in the complete detector system
+        @li zCoord is the z coordinate in the complete detector system
+        @li debug is for debugging purposes
+        @li roundRNumber is the round robin set number
+        @li detType is the detector type see :: detectorType
+        @li version is the version number of this structure format
+    */
+    typedef struct {
+        uint64_t bunchNumber;    /**< is the frame number */
+        uint64_t pre;    /**< something */
+
+    } jf_header;
+
+
+
+
+class jungfrauHighZSingleChipData : public slsDetectorData<uint16_t> {
+ 
+ private:
+  
+  int iframe;
+ public:
+  /**
+     Implements the slsReceiverData structure for the moench02 prototype read out by a module i.e. using the slsReceiver
+     (160x160 pixels, 40 packets 1286 large etc.)
+     \param c crosstalk parameter for the output buffer
+
+  */
+ jungfrauHighZSingleChipData(): slsDetectorData<uint16_t>(256, 256, 256*256*2+sizeof(jf_header)) {
+
+
+     for (int ix=0; ix<256; ix++) {
+       for (int iy=0; iy<256; iy++) {
+	 dataMap[iy][ix]=sizeof(jf_header)+(256*iy+ix)*2;
+#ifdef HIGHZ
+	 dataMask[iy][ix]=0x3fff;
+#endif
+	 }
+     }
+    
+    iframe=0;
+    //  cout << "data struct created" << endl;
+  };
+    
+
+ 
+  /**
+     Returns the value of the selected channel for the given dataset as double.
+     \param data pointer to the dataset (including headers etc)
+     \param ix pixel number in the x direction
+     \param iy pixel number in the y direction
+     \returns data for the selected channel, with inversion if required as double
+
+  */
+  virtual double getValue(char *data, int ix, int iy=0) {
+   
+    uint16_t val=getChannel(data, ix, iy)&0x3fff;
+    return val;
+  };
+
+   
+
+  /* virtual void calcGhost(char *data, int ix, int iy) { */
+  /*   double val=0; */
+  /*   ghost[iy][ix]=0; */
+    
+  /* } */
+
+
+
+  /* virtual void calcGhost(char *data) { */
+  /*   for (int ix=0; ix<25; ix++){ */
+  /*     for (int iy=0; iy<200; iy++) { */
+  /* 	calcGhost(data, ix,iy); */
+  /*     }  */
+  /*   } */
+  /*   // cout << "*" << endl; */
+  /* } */
+
+
+  /* double getGhost(int ix, int iy) { */
+  /*   return 0; */
+  /* }; */
+
+     /**
+
+     Returns the frame number for the given dataset. Purely virtual func.
+     \param buff pointer to the dataset
+     \returns frame number
+
+  */
+
+/* class jfrau_packet_header_t { */
+/*  public: */
+/* 	unsigned char reserved[4]; */
+/* 	unsigned char packetNumber[1]; */
+/* 	unsigned char frameNumber[3]; */
+/* 	unsigned char bunchid[8]; */
+/* }; */
+
+
+
+  int getFrameNumber(char *buff){return ((jf_header*)buff)->bunchNumber;};//*((int*)(buff+5))&0xffffff;};   
+
+  /**
+
+     Returns the packet number for the given dataset. purely virtual func
+     \param buff pointer to the dataset
+     \returns packet number number
+
+
+
+  */
+   int getPacketNumber(char *buff){return 0;}//((*(((int*)(buff+4))))&0xff)+1;};   
+
+/*    /\** */
+
+/*      Loops over a memory slot until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). purely virtual func */
+/*      \param data pointer to the memory to be analyzed */
+/*      \param ndata reference to the amount of data found for the frame, in case the frame is incomplete at the end of the memory slot */
+/*      \param dsize size of the memory slot to be analyzed */
+/*      \returns pointer to the beginning of the last good frame (might be incomplete if ndata smaller than dataSize), or NULL if no frame is found  */
+
+/*   *\/ */
+/*     virtual  char *findNextFrame(char *data, int &ndata, int dsize){ndata=dsize; setDataSize(dsize);  return data;}; */
+
+
+/*    /\** */
+
+/*      Loops over a file stream until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). Can be overloaded for different kind of detectors!  */
+/*      \param filebin input file stream (binary) */
+/*      \returns pointer to the begin of the last good frame, NULL if no frame is found or last frame is incomplete */
+
+/*   *\/ */
+/*     virtual char *readNextFrame(ifstream &filebin){ */
+/*       //	int afifo_length=0;   */
+/*       uint16_t *afifo_cont;  */
+/*       int ib=0; */
+/*       if (filebin.is_open()) { */
+/* 	afifo_cont=new uint16_t[dataSize/2]; */
+/*  	while (filebin.read(((char*)afifo_cont)+ib,2)) { */
+/* 	  ib+=2; */
+/* 	  if (ib==dataSize) break; */
+/* 	} */
+/* 	if (ib>0) { */
+/* 	  iframe++; */
+/* 	  // cout << ib << "-" << endl; */
+/* 	  return (char*)afifo_cont; */
+/* 	} else { */
+/* 	  delete [] afifo_cont; */
+/* 	  return NULL; */
+/* 	} */
+/*       }      */
+/*       return NULL; */
+/*     }; */
+
+
+  virtual char *readNextFrame(ifstream &filebin) {
+    int ff=-1, np=-1;
+    return readNextFrame(filebin, ff, np);
+  };
+
+  virtual char *readNextFrame(ifstream &filebin, int &ff) {
+    int np=-1;
+    return readNextFrame(filebin, ff, np);
+  };
+
+  virtual char *readNextFrame(ifstream &filebin, int& ff, int &np) {
+	  char *data=new char[dataSize];
+	  char *d=readNextFrame(filebin, ff, np, data);
+	  if (d==NULL) {delete [] data; data=NULL;}
+	  return data;
+  }
+
+
+
+
+  virtual char *readNextFrame(ifstream &filebin, int& ff, int &np, char *data) {
+	  char *retval=0;
+	  int  nd;
+	  int fnum = -1;
+	  np=0;
+	  int  pn;
+	  
+	  //  cout << dataSize << endl;
+	  if (ff>=0)
+	    fnum=ff;
+
+	  if (filebin.is_open()) {
+	    if (filebin.read(data, dataSize) ){
+	      ff=getFrameNumber(data);
+	      np=getPacketNumber(data);
+	      return data;
+	    }
+	  }
+	  return NULL;
+  };
+
+
+
+  /**
+
+     Loops over a memory slot until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). purely virtual func
+     \param data pointer to the memory to be analyzed
+     \param ndata reference to the amount of data found for the frame, in case the frame is incomplete at the end of the memory slot
+     \param dsize size of the memory slot to be analyzed
+     \returns pointer to the beginning of the last good frame (might be incomplete if ndata smaller than dataSize), or NULL if no frame is found 
+     
+  */
+  virtual  char *findNextFrame(char *data, int &ndata, int dsize){
+    if (dsize<dataSize) ndata=dsize;
+    else ndata=dataSize;
+    return data;
+
+  }
+
+  //int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
+
+};
+
+
+
+
+#endif
--- a/slsDetectorCalibration/dataStructures/moench03T1ZmqDataNew.h
+++ b/slsDetectorCalibration/dataStructures/moench03T1ZmqDataNew.h
@ -14,6 +14,8 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
  const int nSamples;
  const int offset;

+
+
  double ghost[200][25];
  double xtalk;

@ -29,17 +31,22 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {

  */
  // moench03T1ZmqDataNew(int ns=5000): slsDetectorData<uint16_t>(400, 400, ns*32*2+sizeof(int)), nSamples(ns), offset(sizeof(int)), xtalk(0.00021) {
- moench03T1ZmqDataNew(int ns=5000, int oo=0): slsDetectorData<uint16_t>(400, 400, ns*32*2+oo), nSamples(ns), offset(oo), xtalk(0.00021) {
-
+ moench03T1ZmqDataNew(int ns=5000, int oo=2*2): slsDetectorData<uint16_t>(400, 400, ns*32*2+oo), nSamples(ns), offset(oo), xtalk(0.00021) {
+    cout << "M0.3" << endl;
    int nadc=32;
    int sc_width=25;
    int sc_height=200;
-
-    int adc_nr[32]={300,325,350,375,300,325,350,375,		\
+    
+     int adc_nr[32]={300,325,350,375,300,325,350,375,	\
    		    200,225,250,275,200,225,250,275,\
    		    100,125,150,175,100,125,150,175,\
    		    0,25,50,75,0,25,50,75};
-
+   
+     /*   int adc_nr[32]={350,375,150,175,350,375,150,175,	\
+    		    300,325,100,125,300,325,100,125,\
+    		    250,275,50,75,250,275,50,75,\
+    		    200,225,0,25,200,225,0,25};
+     */
    int row, col;
    
    int isample;
@ -50,11 +57,11 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
    int i;
    int adc4(0);
  
-    for (int ip=0; ip<npackets; ip++) {
-      for (int is=0; is<128; is++) {
-
+    //for (int ip=0; ip<npackets; ip++) {
+    // for (int is=0; is<128; is++) {
+    for (i=0; i<nSamples; i++) {
 	for (iadc=0; iadc<nadc; iadc++) {
-	  i=128*ip+is;
+	  //i=128*ip+is;
 	  adc4=(int)iadc/4;
 	  if (i<sc_width*sc_height) {
 	    //  for (int i=0; i<sc_width*sc_height; i++) {
@ -70,7 +77,7 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
 	  }
 	}
      }
-    }
+  // }

    
    int ii=0;
--- a/slsDetectorCalibration/energyCalibration.cpp
+++ b/slsDetectorCalibration/energyCalibration.cpp
@ -0,0 +1,798 @@
+#include "energyCalibration.h"
+
+#ifdef __CINT
+#define MYROOT
+#endif
+
+
+#ifdef MYROOT
+#include <TMath.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TGraphErrors.h>
+#endif
+
+#include <iostream>
+
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#define ELEM_SWAP(a,b) { register int t=(a);(a)=(b);(b)=t; }
+
+
+using namespace std;
+
+#ifdef MYROOT
+
+Double_t energyCalibrationFunctions::pedestal(Double_t *x, Double_t *par) { 
+    return par[0]-par[1]*sign*x[0];                                      
+}
+
+
+Double_t energyCalibrationFunctions::gaussChargeSharing(Double_t *x, Double_t *par) { 
+  Double_t f, arg=0;
+  // Gaussian exponent
+  if (par[3]!=0) {
+    arg=sign*(x[0]-par[2])/par[3];
+  }
+  // the Gaussian
+  f=TMath::Exp(-1*arg*arg/2.); 
+  // Gaussian + error function
+  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
+  // Gaussian + error function + pedestal
+  return par[4]*f+pedestal(x,par);                                       
+}
+
+Double_t energyCalibrationFunctions::gaussChargeSharingKb(Double_t *x, Double_t *par) { 
+  Double_t f, arg=0,argb=0;
+  // Gaussian exponent
+  if (par[3]!=0) {
+    arg=sign*(x[0]-par[2])/par[3];
+    argb=sign*(x[0]-(par[6]*par[2]))/par[3]; // using absolute kb mean might seem better but like this the ratio can be fixed
+  }
+  // the Gaussian
+  f=TMath::Exp(-1*arg*arg/2.); 
+  f=f+par[7]*(TMath::Exp(-1*argb*argb/2.));
+  // Gaussian + error function
+  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
+  f=f+par[7]*par[5]/2.*(TMath::Erfc(argb/(TMath::Sqrt(2.)))); 
+  // Gaussian + error function + pedestal
+  return par[4]*f+pedestal(x,par);                                       
+}
+
+Double_t energyCalibrationFunctions::gaussChargeSharingKaDoublet(Double_t *x, Double_t *par) { 
+  Double_t f, f2, arg=0, arg2=0;
+  // Gaussian exponent
+  if (par[3]!=0) {
+    arg=sign*(x[0]-par[2])/par[3];
+    arg2=sign*(x[0]-par[6])/par[3];
+  }
+  // the Gaussian
+  f=TMath::Exp(-1*arg*arg/2.); 
+  f2=TMath::Exp(-1*arg2*arg2/2.); 
+  // Gaussian + error function
+  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
+  f2=f2+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); // shouldn't this be arg2?
+  // Gaussian + error function + pedestal
+  return par[4]*f+par[7]*f2+pedestal(x,par);                                       
+}
+
+Double_t energyCalibrationFunctions::gaussChargeSharingPixel(Double_t *x, Double_t *par) { 
+  Double_t f;
+  if (par[3]<=0 || par[2]*(*x)<=0 || par[5]<0 || par[4]<=0) return 0;
+
+  Double_t pp[3];
+
+  pp[0]=0;
+  pp[1]=par[2];
+  pp[2]=par[3];
+  
+
+  f=(par[5]-par[6]*(TMath::Log(*x/par[2])))*erfBox(x,pp);
+  f+=par[4]*TMath::Gaus(*x, par[2], par[3], kTRUE);
+  return f+pedestal(x,par);                                       
+}
+
+Double_t energyCalibrationFunctions::erfBox(Double_t *z, Double_t *par) {
+
+  
+  
+  Double_t m=par[0];
+  Double_t M=par[1];
+  
+  if (par[0]>par[1]) {
+    m=par[1];
+    M=par[0];
+  }
+  
+  if (m==M)
+    return 0;
+
+
+  if (par[2]<=0) {
+    if (*z>=m && *z<=M)
+      return 1./(M-m);
+    else
+      return 0;
+
+  }
+
+  return (TMath::Erfc((z[0]-M)/par[2])-TMath::Erfc((z[0]-m)/par[2]))*0.5/(M-m);
+
+}
+
+
+// basic erf function
+Double_t energyCalibrationFunctions::erfFunction(Double_t *x, Double_t *par) {	
+  double arg=0;
+  if (par[1]!=0) arg=(par[0]-x[0])/par[1];
+  return ((par[2]/2.*(1+TMath::Erf(sign*arg/(TMath::Sqrt(2))))));  
+};
+  
+
+Double_t energyCalibrationFunctions::erfFunctionChargeSharing(Double_t *x, Double_t *par) {	       
+  Double_t f;		
+  
+  f=erfFunction(x, par+2)*(1+par[5]*(par[2]-x[0]))+par[0]-par[1]*x[0]*sign;		
+  return f;								
+};
+  
+  
+Double_t energyCalibrationFunctions::erfFuncFluo(Double_t *x, Double_t *par) {
+  Double_t f;							       
+  f=erfFunctionChargeSharing(x, par)+erfFunction(x, par+6)*(1+par[9]*(par[6]-x[0])); 
+  return f;							
+};
+#endif
+
+double energyCalibrationFunctions::median(double *x, int n){
+  // sorts x into xmed array and returns median 
+  // n is number of values already in the xmed array
+  double xmed[n];
+  int k,i,j;
+
+  for (i=0; i<n; i++) {
+    k=0;
+    for (j=0; j<n; j++) {
+      if(*(x+i)>*(x+j))
+	k++;
+      if (*(x+i)==*(x+j)) {
+	if (i>j) 
+	  k++;
+      }
+    }
+    xmed[k]=*(x+i);
+  }
+  k=n/2;
+  return xmed[k];
+}
+
+
+int energyCalibrationFunctions::quick_select(int arr[], int n){
+    int low, high ;
+    int median;
+    int middle, ll, hh;
+
+    low = 0 ; high = n-1 ; median = (low + high) / 2;
+    for (;;) {
+        if (high <= low) /* One element only */
+            return arr[median] ;
+
+        if (high == low + 1) {  /* Two elements only */
+            if (arr[low] > arr[high])
+                ELEM_SWAP(arr[low], arr[high]) ;
+            return arr[median] ;
+        }
+
+    /* Find median of low, middle and high items; swap into position low */
+    middle = (low + high) / 2;
+    if (arr[middle] > arr[high])    ELEM_SWAP(arr[middle], arr[high]) ;
+    if (arr[low] > arr[high])       ELEM_SWAP(arr[low], arr[high]) ;
+    if (arr[middle] > arr[low])     ELEM_SWAP(arr[middle], arr[low]) ;
+
+    /* Swap low item (now in position middle) into position (low+1) */
+    ELEM_SWAP(arr[middle], arr[low+1]) ;
+
+    /* Nibble from each end towards middle, swapping items when stuck */
+    ll = low + 1;
+    hh = high;
+    for (;;) {
+        do ll++; while (arr[low] > arr[ll]) ;
+        do hh--; while (arr[hh]  > arr[low]) ;
+
+        if (hh < ll)
+        break;
+
+        ELEM_SWAP(arr[ll], arr[hh]) ;
+    }
+
+    /* Swap middle item (in position low) back into correct position */
+    ELEM_SWAP(arr[low], arr[hh]) ;
+
+    /* Re-set active partition */
+    if (hh <= median)
+        low = ll;
+        if (hh >= median)
+        high = hh - 1;
+    }
+}
+
+int energyCalibrationFunctions::kth_smallest(int *a, int n, int k){
+    register int i,j,l,m ;
+    register double x ;
+
+    l=0 ; m=n-1 ;
+    while (l<m) {
+        x=a[k] ;
+        i=l ;
+        j=m ;
+        do {
+            while (a[i]<x) i++ ;
+            while (x<a[j]) j-- ;
+            if (i<=j) {
+                ELEM_SWAP(a[i],a[j]) ;
+                i++ ; j-- ;
+            }
+        } while (i<=j) ;
+        if (j<k) l=i ;
+        if (k<i) m=j ;
+    }
+    return a[k] ;
+}
+
+
+
+#ifdef MYROOT
+Double_t energyCalibrationFunctions::spectrum(Double_t *x, Double_t *par) {
+  return gaussChargeSharing(x,par);	
+}
+
+Double_t energyCalibrationFunctions::spectrumkb(Double_t *x, Double_t *par) {
+  return gaussChargeSharingKb(x,par);	
+}
+
+Double_t energyCalibrationFunctions::spectrumkadoublet(Double_t *x, Double_t *par) {
+  return gaussChargeSharingKaDoublet(x,par);	
+}
+
+Double_t energyCalibrationFunctions::spectrumPixel(Double_t *x, Double_t *par) {
+  return gaussChargeSharingPixel(x,par);	
+}
+
+
+Double_t energyCalibrationFunctions::scurve(Double_t *x, Double_t *par) {
+  return erfFunctionChargeSharing(x,par);
+}
+
+
+Double_t energyCalibrationFunctions::scurveFluo(Double_t *x, Double_t *par) {
+  return erfFuncFluo(x,par);						
+}
+#endif
+
+energyCalibration::energyCalibration() : 
+#ifdef MYROOT	
+					 fit_min(-1),	
+					 fit_max(-1),	
+					 bg_offset(-1),	
+					 bg_slope(-1),	
+					 flex(-1),
+					 noise(-1),
+					 ampl(-1),
+					 cs_slope(-1),
+					 kb_mean(-1),
+					 kb_frac(-1),
+					 mean2(-1),
+					 ampl2(-1),
+					 fscurve(NULL),
+					 fspectrum(NULL),
+					 fspectrumkb(NULL),
+					 fspectrumkadoublet(NULL),
+#endif
+					 funcs(NULL),
+					 plot_flag(1), // fit parameters output to screen
+					 cs_flag(1)
+{
+
+#ifdef MYROOT	
+  funcs=new energyCalibrationFunctions();
+  
+  fscurve=new TF1("fscurve",funcs,&energyCalibrationFunctions::scurve,0,1000,6,"energyCalibrationFunctions","scurve");	
+  fscurve->SetParNames("Background Offset","Background Slope","Inflection Point","Noise RMS", "Number of Photons","Charge Sharing Slope");
+
+  fspectrum=new TF1("fspectrum",funcs,&energyCalibrationFunctions::spectrum,0,1000,6,"energyCalibrationFunctions","spectrum");	
+  fspectrum->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal");
+  fspectrumkb=new TF1("fspectrumkb",funcs,&energyCalibrationFunctions::spectrumkb,0,1000,8,"energyCalibrationFunctions","spectrumkb");	
+  fspectrumkb->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","kb mean","kb frac");
+
+  fspectrumkadoublet=new TF1("fspectrumkadoublet",funcs,&energyCalibrationFunctions::spectrumkadoublet,0,1000,8,"energyCalibrationFunctions","spectrumkadoublet");	
+  fspectrumkadoublet->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","ka2 mean","n2");
+
+  fspixel=new TF1("fspixel",funcs,&energyCalibrationFunctions::spectrumPixel,0,1000,7,"energyCalibrationFunctions","spectrumPixel");	
+  fspixel->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","Corner");
+
+#endif
+
+
+}
+
+
+
+void energyCalibration::fixParameter(int ip, Double_t val){
+  
+  fscurve->FixParameter(ip, val);
+  fspectrum->FixParameter(ip, val);
+  fspectrumkb->FixParameter(ip, val);
+  fspectrumkadoublet->FixParameter(ip, val);
+}
+
+
+void energyCalibration::releaseParameter(int ip){
+
+  fscurve->ReleaseParameter(ip);
+  fspectrum->ReleaseParameter(ip);
+  fspectrumkb->ReleaseParameter(ip);
+  fspectrumkadoublet->ReleaseParameter(ip);
+}
+
+
+
+
+
+
+
+energyCalibration::~energyCalibration(){ 
+#ifdef MYROOT
+  delete fscurve;
+  delete fspectrum;
+  delete fspectrumkb;
+  delete fspectrumkadoublet;
+#endif
+  
+}
+
+#ifdef MYROOT
+
+
+
+
+
+TH1F* energyCalibration::createMedianHistogram(TH2F* h2, int ch0, int nch, int direction) {
+
+  if (h2==NULL || nch==0)
+    return NULL;
+
+  double *x=new double[nch];
+  TH1F *h1=NULL;
+  
+  double val=-1;
+
+  if (direction==0) {
+    h1=new TH1F("median","Median",h2->GetYaxis()->GetNbins(),h2->GetYaxis()->GetXmin(),h2->GetYaxis()->GetXmax());
+    for (int ib=0; ib<h1->GetXaxis()->GetNbins(); ib++) {
+      for (int ich=0; ich<nch; ich++) {
+	x[ich]=h2->GetBinContent(ch0+ich+1,ib+1);
+      }
+      val=energyCalibrationFunctions::median(x, nch);
+      h1->SetBinContent(ib+1,val);
+    }
+  } else if (direction==1) {   
+    h1=new TH1F("median","Median",h2->GetXaxis()->GetNbins(),h2->GetXaxis()->GetXmin(),h2->GetXaxis()->GetXmax());
+    for (int ib=0; ib<h1->GetYaxis()->GetNbins(); ib++) {
+      for (int ich=0; ich<nch; ich++) {
+	x[ich]=h2->GetBinContent(ib+1,ch0+ich+1);
+      }
+      val=energyCalibrationFunctions::median(x, nch);
+      h1->SetBinContent(ib+1,val);
+    }
+  }
+  delete [] x;
+
+  return h1;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void energyCalibration::setStartParameters(Double_t *par){	
+  bg_offset=par[0];						
+  bg_slope=par[1];						
+  flex=par[2];							
+  noise=par[3];							
+  ampl=par[4];							
+  cs_slope=par[5];						
+}
+
+void energyCalibration::setStartParametersKb(Double_t *par){	
+  bg_offset=par[0];						
+  bg_slope=par[1];						
+  flex=par[2];							
+  noise=par[3];							
+  ampl=par[4];							
+  cs_slope=par[5];						
+  kb_mean=par[6];
+  kb_frac=par[7];
+  //fit_min = 400; // used for soleil flat field
+  //fit_max = 800;
+}
+
+void energyCalibration::setStartParametersKaDoublet(Double_t *par){	
+  bg_offset=par[0];						
+  bg_slope=par[1];						
+  flex=par[2];							
+  noise=par[3];							
+  ampl=par[4];							
+  cs_slope=par[5];						
+  mean2=par[6];
+  ampl2=par[7];
+  //fit_min = 400; // used for soleil flat field
+  //fit_max = 800;
+}
+
+
+void energyCalibration::getStartParameters(Double_t *par){	
+  par[0]=bg_offset;
+  par[1]=bg_slope;
+  par[2]=flex;
+  par[3]=noise;
+  par[4]=ampl;				
+  par[5]=cs_slope;				
+}
+
+#endif
+int energyCalibration::setChargeSharing(int p) {
+  if (p>=0) {
+    cs_flag=p; 
+#ifdef MYROOT  
+    if (p) {
+      fscurve->ReleaseParameter(5);
+      fspectrum->ReleaseParameter(1);
+      fspectrumkb->ReleaseParameter(1);
+      fspectrumkadoublet->ReleaseParameter(1);
+    } else {
+      fscurve->FixParameter(5,0);
+      fspectrum->FixParameter(1,0);
+      fspectrumkb->FixParameter(1,0);
+      fspectrumkadoublet->FixParameter(1,0);
+    }
+#endif
+  } 
+  
+  return cs_flag;
+}
+
+ 
+#ifdef MYROOT  
+void energyCalibration::initFitFunction(TF1 *fun, TH1 *h1) {
+
+ Double_t min=fit_min, max=fit_max; 
+
+ Double_t mypar[6];
+  
+ if (max==-1) 
+    max=h1->GetXaxis()->GetXmax();
+ 
+  if (min==-1) 
+    min=h1->GetXaxis()->GetXmin();
+
+  
+  if (bg_offset==-1)
+    mypar[0]=0;
+  else
+    mypar[0]=bg_offset;
+
+
+  if (bg_slope==-1)
+    mypar[1]=0;
+  else
+    mypar[1]=bg_slope;
+
+
+  if (flex==-1)
+    mypar[2]=(min+max)/2.;
+  else
+    mypar[2]=flex;
+
+
+  if (noise==-1)
+    mypar[3]=0.1;
+  else
+    mypar[3]=noise;
+
+  if (ampl==-1)
+    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
+  else
+    mypar[4]=ampl;
+
+  if (cs_slope==-1)
+    mypar[5]=0;
+  else
+    mypar[5]=cs_slope;
+ 
+  fun->SetParameters(mypar);
+
+  fun->SetRange(min,max);
+
+}
+
+void energyCalibration::initFitFunctionKb(TF1 *fun, TH1 *h1) {
+
+ Double_t min=fit_min, max=fit_max; 
+
+ Double_t mypar[8];
+  
+ if (max==-1) 
+    max=h1->GetXaxis()->GetXmax();
+ 
+  if (min==-1) 
+    min=h1->GetXaxis()->GetXmin();
+
+  
+  if (bg_offset==-1)
+    mypar[0]=0;
+  else
+    mypar[0]=bg_offset;
+
+
+  if (bg_slope==-1)
+    mypar[1]=0;
+  else
+    mypar[1]=bg_slope;
+
+
+  if (flex==-1)
+    mypar[2]=(min+max)/2.;
+  else
+    mypar[2]=flex;
+
+
+  if (noise==-1)
+    mypar[3]=0.1;
+  else
+    mypar[3]=noise;
+
+  if (ampl==-1)
+    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
+  else
+    mypar[4]=ampl;
+
+  if (cs_slope==-1)
+    mypar[5]=0;
+  else
+    mypar[5]=cs_slope;
+
+  if (kb_mean==-1)
+    mypar[6]=0;
+  else
+    mypar[6]=kb_mean;
+
+  if (kb_frac==-1)
+    mypar[7]=0;
+  else
+    mypar[7]=kb_frac;
+ 
+  fun->SetParameters(mypar);
+
+  fun->SetRange(min,max);
+
+}
+
+void energyCalibration::initFitFunctionKaDoublet(TF1 *fun, TH1 *h1) {
+
+ Double_t min=fit_min, max=fit_max; 
+
+ Double_t mypar[8];
+  
+ if (max==-1) 
+    max=h1->GetXaxis()->GetXmax();
+ 
+  if (min==-1) 
+    min=h1->GetXaxis()->GetXmin();
+
+  
+  if (bg_offset==-1)
+    mypar[0]=0;
+  else
+    mypar[0]=bg_offset;
+
+
+  if (bg_slope==-1)
+    mypar[1]=0;
+  else
+    mypar[1]=bg_slope;
+
+
+  if (flex==-1)
+    mypar[2]=(min+max)/2.;
+  else
+    mypar[2]=flex;
+
+
+  if (noise==-1)
+    mypar[3]=0.1;
+  else
+    mypar[3]=noise;
+
+  if (ampl==-1)
+    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
+  else
+    mypar[4]=ampl;
+
+  if (cs_slope==-1)
+    mypar[5]=0;
+  else
+    mypar[5]=cs_slope;
+
+  if (mean2==-1)
+    mypar[6]=0;
+  else
+    mypar[6]=mean2;
+
+  if (ampl2==-1)
+    mypar[7]=0;
+  else
+    mypar[7]=ampl2;
+ 
+  fun->SetParameters(mypar);
+
+  fun->SetRange(min,max);
+
+}
+
+TF1* energyCalibration::fitFunction(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
+
+
+  TF1* fitfun;
+
+  char fname[100];
+
+  strcpy(fname, fun->GetName());
+
+  if (plot_flag) {
+    h1->Fit(fname,"R0Q");
+  } else
+    h1->Fit(fname,"R0Q");
+
+  fitfun= h1->GetFunction(fname);
+  fitfun->GetParameters(mypar);
+  for (int ip=0; ip<6; ip++) {
+    emypar[ip]=fitfun->GetParError(ip);
+  }
+  return fitfun;
+}
+
+TF1* energyCalibration::fitFunctionKb(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
+
+
+  TF1* fitfun;
+
+  char fname[100];
+
+  strcpy(fname, fun->GetName());
+
+  if (plot_flag) {
+    h1->Fit(fname,"R0Q");
+  } else
+    h1->Fit(fname,"R0Q");
+
+  fitfun= h1->GetFunction(fname);
+  fitfun->GetParameters(mypar);
+  for (int ip=0; ip<8; ip++) {
+    emypar[ip]=fitfun->GetParError(ip);
+  }
+  return fitfun;
+}
+
+TF1* energyCalibration::fitFunctionKaDoublet(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
+
+
+  TF1* fitfun;
+
+  char fname[100];
+
+  strcpy(fname, fun->GetName());
+
+  if (plot_flag) {
+    h1->Fit(fname,"R0Q");
+  } else
+    h1->Fit(fname,"R0Q");
+
+
+  fitfun= h1->GetFunction(fname);
+  fitfun->GetParameters(mypar);
+  for (int ip=0; ip<8; ip++) {
+    emypar[ip]=fitfun->GetParError(ip);
+  }
+  return fitfun;
+}
+
+TF1* energyCalibration::fitSCurve(TH1 *h1, Double_t *mypar, Double_t *emypar) {
+  initFitFunction(fscurve,h1);
+  return fitFunction(fscurve, h1, mypar, emypar);
+}
+
+
+
+
+
+TF1* energyCalibration::fitSpectrum(TH1 *h1, Double_t *mypar, Double_t *emypar) {
+  initFitFunction(fspectrum,h1);
+  return fitFunction(fspectrum, h1, mypar, emypar);
+}
+
+TF1* energyCalibration::fitSpectrumKb(TH1 *h1, Double_t *mypar, Double_t *emypar) {
+  initFitFunctionKb(fspectrumkb,h1);
+  return fitFunctionKb(fspectrumkb, h1, mypar, emypar);
+}
+
+TF1* energyCalibration::fitSpectrumKaDoublet(TH1 *h1, Double_t *mypar, Double_t *emypar) {
+  initFitFunctionKaDoublet(fspectrumkadoublet,h1);
+  return fitFunctionKaDoublet(fspectrumkadoublet, h1, mypar, emypar);
+}
+
+
+TGraphErrors* energyCalibration::linearCalibration(int nscan, Double_t *en, Double_t *een, Double_t *fl, Double_t *efl, Double_t &gain, Double_t &off, Double_t &egain, Double_t &eoff) { 
+ 
+  TGraphErrors *gr;
+ 
+  Double_t  mypar[2];
+ 
+  gr = new TGraphErrors(nscan,en,fl,een,efl);
+
+  if (plot_flag) {
+    gr->Fit("pol1");
+    gr->SetMarkerStyle(20);
+  } else
+    gr->Fit("pol1","0Q");
+        
+  TF1 *fitfun= gr->GetFunction("pol1"); 
+  fitfun->GetParameters(mypar);
+
+  egain=fitfun->GetParError(1);
+  eoff=fitfun->GetParError(0);
+
+  gain=funcs->setScanSign()*mypar[1];
+  
+  off=mypar[0]; 
+  
+  return gr;
+}
+
+
+TGraphErrors* energyCalibration::calibrate(int nscan, Double_t *en, Double_t *een, TH1F **h1, Double_t &gain, Double_t &off, Double_t &egain, Double_t &eoff, int integral) {
+
+  TH1F *h;
+
+  Double_t mypar[6], emypar[6];
+  Double_t fl[nscan], efl[nscan];
+  
+
+  for (int ien=0; ien<nscan; ien++) {
+    h=h1[ien];
+    if (integral)
+      fitSCurve(h,mypar,emypar);
+    else
+      fitSpectrum(h,mypar,emypar);
+
+    fl[ien]=mypar[2];
+    efl[ien]=emypar[2];
+  }
+  return linearCalibration(nscan,en,een,fl,efl,gain,off, egain, eoff);
+
+}
+
+#endif
+
+
+
+
--- a/slsDetectorCalibration/energyCalibration.h
+++ b/slsDetectorCalibration/energyCalibration.h
@ -98,6 +98,8 @@ class energyCalibrationFunctions {
      par[5] is the fractional height of the charge sharing pedestal (scales with par[3])
  */
  Double_t gaussChargeSharing(Double_t *x, Double_t *par);
+  Double_t gaussChargeSharingKb(Double_t *x, Double_t *par);
+  Double_t gaussChargeSharingKaDoublet(Double_t *x, Double_t *par);
  /** 
      Gaussian Function with charge sharing pedestal
      par[0] is the absolute height of the background pedestal
@ -153,6 +155,8 @@ Double_t erfFuncFluo(Double_t *x, Double_t *par);
      par[5] is the fractional height of the charge sharing pedestal (scales with par[4]
  */
  Double_t spectrum(Double_t *x, Double_t *par);
+  Double_t spectrumkb(Double_t *x, Double_t *par);
+  Double_t spectrumkadoublet(Double_t *x, Double_t *par);

  /** 
      static function Gaussian with charge sharing pedestal with the correct scan sign
@ -285,7 +289,9 @@ class energyCalibration  {
      par[5] is the angual coefficient of the charge sharing slope (scales with par[3]) -- always positive
  */
  void setStartParameters(Double_t *par);
-  
+  void setStartParametersKb(Double_t *par);
+  void setStartParametersKaDoublet(Double_t *par);
+
 /** get start parameters for the s-curve function
    \param par parameters, -1 means auto-calculated
      par[0] is the  pedestal 
@ -315,16 +321,8 @@ class energyCalibration  {
     \returns the fitted function - can be used e.g. to get the Chi2 or similar
  */
  TF1 *fitSpectrum(TH1 *h1, Double_t *mypar, Double_t *emypar);
-
-
-  /**
-     fits histogram with the spectrum
-     \param h1 1d-histogram to be fitted
-     \param mypar pointer to fit parameters array 
-     \param emypar pointer to fit parameter errors
-     \returns the fitted function - can be used e.g. to get the Chi2 or similar
-  */
-  TF1 *fitSpectrumPixel(TH1 *h1, Double_t *mypar, Double_t *emypar);
+  TF1 *fitSpectrumKb(TH1 *h1, Double_t *mypar, Double_t *emypar);
+  TF1 *fitSpectrumKaDoublet(TH1 *h1, Double_t *mypar, Double_t *emypar);


  /**
@ -399,6 +397,8 @@ class energyCalibration  {
 */
  
  void initFitFunction(TF1 *fun, TH1 *h1);
+  void initFitFunctionKb(TF1 *fun, TH1 *h1);
+  void initFitFunctionKaDoublet(TF1 *fun, TH1 *h1);


  /**
@ -410,6 +410,8 @@ class energyCalibration  {
     \returns the fitted function - can be used e.g. to get the Chi2 or similar
  */
  TF1 *fitFunction(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  
+  TF1 *fitFunctionKb(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  
+  TF1 *fitFunctionKaDoublet(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  

 #endif

@ -423,11 +425,16 @@ class energyCalibration  {
  Double_t noise; /**< start value for the noise */
  Double_t ampl; /**< start value for the number of photons */
  Double_t cs_slope; /**< start value for the charge sharing slope */
-
+  Double_t kb_mean;
+  Double_t kb_frac;
+  Double_t mean2;
+  Double_t ampl2;

  TF1 *fscurve; /**< function with which the s-curve will be fitted */

  TF1 *fspectrum; /**< function with which the spectrum will be fitted */
+  TF1 *fspectrumkb; /**< function with which the spectrum will be fitted */
+  TF1 *fspectrumkadoublet; /**< function with which the spectrum will be fitted */

  TF1 *fspixel; /**< function with which the spectrum will be fitted */

--- a/slsDetectorCalibration/jungfrauExecutables/Makefile.cluster_finder
+++ b/slsDetectorCalibration/jungfrauExecutables/Makefile.cluster_finder
@ -0,0 +1,47 @@
+#module add CBFlib/0.9.5
+INCDIR=-I. -I../ -I../interpolations  -I../interpolations/etaVEL  -I../dataStructures  -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/ 
+
+LDFLAG= ../tiffIO.cpp -L/usr/lib64/ -lpthread -lm  -lstdc++   -pthread -lrt    -ltiff -O3  -std=c++11
+
+MAIN=jungfrauClusterFinder.cpp
+
+
+all: jungfrauClusterFinder jungfrauMakeEta jungfrauInterpolation jungfrauNoInterpolation jungfrauPhotonCounter jungfrauAnalog
+
+
+
+jungfrauClusterFinder:  jungfrauClusterFinder.cpp  $(INCS) clean
+			 g++ -o jungfrauClusterFinder  jungfrauClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  
+
+
+jungfrauClusterFinderHighZ:  jungfrauClusterFinder.cpp  $(INCS) clean
+			 g++ -o jungfrauClusterFinderHighZ  jungfrauClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DHIGHZ 
+
+
+
+
+jungfrauMakeEta:  jungfrauInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauMakeEta jungfrauInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DFF
+
+jungfrauInterpolation:  jungfrauInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauInterpolation jungfrauInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  
+
+jungfrauNoInterpolation:  jungfrauNoInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauNoInterpolation jungfrauNoInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) 
+
+jungfrauPhotonCounter: jungfrauPhotonCounter.cpp   $(INCS) clean
+			 g++ -o jungfrauPhotonCounter  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER
+
+jungfrauAnalog: jungfrauPhotonCounter.cpp  $(INCS) clean
+			 g++ -o jungfrauAnalog  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG
+
+jungfrauPhotonCounterHighZ: jungfrauPhotonCounter.cpp   $(INCS) clean
+			 g++ -o jungfrauPhotonCounterHighZ  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DHIGHZ
+
+jungfrauAnalogHighZ: jungfrauPhotonCounter.cpp  $(INCS) clean
+			 g++ -o jungfrauAnalogHighZ  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG -DHIGHZ
+
+clean: 	
+	rm -f  jungfrauClusterFinder jungfrauMakeEta jungfrauInterpolation jungfrauNoInterpolation jungfrauPhotonCounter jungfrauAnalog
+
+
--- a/slsDetectorCalibration/jungfrauExecutables/Makefile.cluster_finder~
+++ b/slsDetectorCalibration/jungfrauExecutables/Makefile.cluster_finder~
@ -0,0 +1,47 @@
+#module add CBFlib/0.9.5
+INCDIR=-I. -I../ -I../interpolations  -I../interpolations/etaVEL  -I../dataStructures  -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/
+
+LDFLAG= ../tiffIO.cpp -L/usr/lib64/ -lpthread -lm  -lstdc++   -pthread -lrt    -ltiff -O3  -std=c++11
+
+MAIN=moench03ClusterFinder.cpp
+
+
+all: moenchClusterFinder moenchMakeEta moenchInterpolation moenchNoInterpolation moenchPhotonCounter moenchAnalog
+
+
+
+moenchClusterFinder:  moench03ClusterFinder.cpp  $(INCS) clean
+			 g++ -o moenchClusterFinder  moench03ClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DNEWRECEIVER 
+
+
+moenchClusterFinderHighZ:  moench03ClusterFinder.cpp  $(INCS) clean
+			 g++ -o moenchClusterFinderHighZ  moench03ClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DNEWRECEIVER -DHIGHZ 
+
+
+
+
+moenchMakeEta:  moench03Interpolation.cpp  $(INCS) clean
+			 g++ -o moenchMakeEta moench03Interpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DFF
+
+moenchInterpolation:  moench03Interpolation.cpp  $(INCS) clean
+			 g++ -o moenchInterpolation moench03Interpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  
+
+moenchNoInterpolation:  moench03NoInterpolation.cpp  $(INCS) clean
+			 g++ -o moenchNoInterpolation moench03NoInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) 
+
+moenchPhotonCounter: moenchPhotonCounter.cpp   $(INCS) clean
+			 g++ -o moenchPhotonCounter  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER
+
+moenchAnalog: moenchPhotonCounter.cpp  $(INCS) clean
+			 g++ -o moenchAnalog  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG
+
+moenchPhotonCounterHighZ: moenchPhotonCounter.cpp   $(INCS) clean
+			 g++ -o moenchPhotonCounterHighZ  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DHIGHZ
+
+moenchAnalogHighZ: moenchPhotonCounter.cpp  $(INCS) clean
+			 g++ -o moenchAnalogHighZ  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG -DHIGHZ
+
+clean: 	
+	rm -f  moenchClusterFinder moenchMakeEta moenchInterpolation moenchNoInterpolation moenchPhotonCounter moenchAnalog
+
+
--- a/slsDetectorCalibration/jungfrauExecutables/Makefile.zmq
+++ b/slsDetectorCalibration/jungfrauExecutables/Makefile.zmq
@ -0,0 +1,23 @@
+
+INCDIR=   -I. -I../dataStructures ../tiffIO.cpp -I../ -I../interpolations/ -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/ -I../../libs/rapidjson/
+LDFLAG= -L/usr/lib64/ -lpthread -lm  -lstdc++  -lzmq -pthread -lrt -ltiff   -O3  -std=c++11 -Wall -L../../build/bin/ -lSlsSupport
+#-L../../bin -lhdf5  -L.
+
+#DESTDIR?=../bin
+
+all:  moenchZmqProcess moenchZmq04Process
+ #moenchZmqProcessCtbGui
+
+moenchZmqProcess:  moenchZmqProcess.cpp   clean
+		      g++ -o moenchZmqProcess  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP 
+
+moenchZmq04Process:  moenchZmqProcess.cpp   clean
+		      g++ -o moench04ZmqProcess  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP -DMOENCH04 
+
+#moenchZmqProcessCtbGui:  moenchZmqProcess.cpp   clean
+#		      g++ -o moenchZmqProcessCtbGui  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP -DCTBGUI
+
+clean: 	
+	rm -f  moenchZmqProcess  
+
+
--- a/slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder
+++ b/slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder
--- a/slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder.cpp
+++ b/slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder.cpp
@ -0,0 +1,161 @@
+//#include "sls/ansi.h"
+#include <iostream>
+
+
+//#include "moench03T1ZmqData.h"
+#include "jungfrauHighZSingleChipData.h"
+
+
+#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<6) {
+    cout << "Usage is " << argv[0] << "indir outdir fname runmin runmax " << endl;
+    return 1;
+  }
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=1;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int nx=400, ny=400;
+  int save=1;
+  int nsigma=5;
+  int nped=1000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+
+
+
+  jungfrauHighZSingleChipData *decoder=new  jungfrauHighZSingleChipData();
+
+  decoder->getDetectorSize(nx,ny);
+  cout << "nx " << nx << " ny " << ny << endl;
+
+  //moench03T1ZmqData *decoder=new  moench03T1ZmqData();
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, 0, nped, 200);
+  //  char tit[10000];
+  cout << "filter " << endl;
+
+
+
+
+  int* image;
+  filter->newDataSet();
+
+
+  int ff, np;
+  int dsize=decoder->getDataSize();
+  cout << " data size is " << dsize;
+  
+
+  char data[dsize];
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=atoi(argv[4]);
+  int runmax=atoi(argv[5]);
+  
+  char fname[10000];
+  char outfname[10000];
+  char imgfname[10000];
+  char pedfname[10000];
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "fileformat is " << fformat << endl;
+  
+
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+
+  char* buff;
+  multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+
+ 
+  mt->setDetectorMode(ePhotonCounting);
+  mt->setFrameMode(eFrame);
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  cout << "mt " << endl;
+
+  int ifr=0;
+ 
+
+  for (int irun=runmin; irun<runmax; irun++) {
+    sprintf(fn,fformat,irun);
+    sprintf(fname,"%s/%s.raw",indir,fn);
+    sprintf(outfname,"%s/%s.clust",outdir,fn);
+    sprintf(imgfname,"%s/%s.tiff",outdir,fn);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    if (filebin.is_open()){
+      of=fopen(outfname,"w");
+      if (of) {
+  	mt->setFilePointer(of);
+	//	cout << "file pointer set " << endl;
+      } else {
+  	cout << "Could not open "<< outfname << " for writing " << endl;
+  	mt->setFilePointer(NULL);
+  	return 1;
+      }
+      //     //while read frame 
+      ff=-1;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+
+  	mt->pushData(buff);
+  	mt->nextThread();
+  	mt->popFree(buff);
+	ifr++;
+	if (ifr%10000==0) cout << ifr << " " << ff << endl;
+	ff=-1;
+      }
+        cout << "--" << endl;
+      filebin.close();	 
+      while (mt->isBusy()) {;}//wait until all data are processed from the queues
+      if (of)
+  	fclose(of);
+      
+      mt->writeImage(imgfname);
+      mt->clearImage();
+   
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+
+    } else 
+     cout << "Could not open "<< fname << " for reading " << endl;
+      
+    
+  }
+    
+
+  return 0;
+}
+
--- a/slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder.cpp~
+++ b/slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder.cpp~
@ -0,0 +1,237 @@
+//#include "sls/ansi.h"
+#include <iostream>
+
+
+//#include "moench03T1ZmqData.h"
+#ifdef NEWRECEIVER
+#ifndef RECT
+#include "moench03T1ReceiverDataNew.h"
+#endif
+
+#ifdef RECT
+#include "moench03T1ReceiverDataNewRect.h"
+#endif
+
+#endif
+
+
+#ifdef CSAXS_FP
+#include "moench03T1ReceiverData.h"
+#endif 
+#ifdef OLDDATA
+#include "moench03Ctb10GbT1Data.h"
+#endif 
+
+#ifdef REORDERED
+#include "moench03T1ReorderedData.h"
+#endif
+
+// #include "interpolatingDetector.h"
+//#include "etaInterpolationPosXY.h"
+// #include "linearInterpolation.h"
+// #include "noInterpolation.h"
+#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+//#include "interpolatingDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<6) {
+    cout << "Usage is " << argv[0] << "indir outdir fname runmin runmax " << endl;
+    return 1;
+  }
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=1;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int nx=400, ny=400;
+  int save=1;
+  int nsigma=5;
+  int nped=1000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+
+
+
+
+#ifdef NEWRECEIVER
+#ifdef RECT
+  cout << "Should be rectangular!" <<endl;
+#endif
+  moench03T1ReceiverDataNew *decoder=new  moench03T1ReceiverDataNew();
+  cout << "RECEIVER DATA WITH ONE HEADER!"<<endl;
+#endif
+
+#ifdef CSAXS_FP
+  moench03T1ReceiverData *decoder=new  moench03T1ReceiverData();
+  cout << "RECEIVER DATA WITH ALL HEADERS!"<<endl;
+#endif
+
+#ifdef OLDDATA
+  moench03Ctb10GbT1Data *decoder=new  moench03Ctb10GbT1Data();
+  cout << "OLD RECEIVER DATA!"<<endl;
+#endif
+
+#ifdef REORDERED
+  moench03T1ReorderedData *decoder=new  moench03T1ReorderedData();
+  cout << "REORDERED DATA!"<<endl;
+#endif
+
+
+  decoder->getDetectorSize(nx,ny);
+  cout << "nx " << nx << " ny " << ny << endl;
+
+  //moench03T1ZmqData *decoder=new  moench03T1ZmqData();
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, 0, nped, 200);
+  //  char tit[10000];
+  cout << "filter " << endl;
+
+
+
+  // filter->readPedestals("/scratch/ped_100.tiff");
+  // interp->readFlatField("/scratch/eta_100.tiff",etamin,etamax);
+  // cout << "filter "<< endl;
+  
+
+  int size = 327680;////atoi(argv[3]);
+  
+  int* image;
+	//int* image =new int[327680/sizeof(int)];
+  filter->newDataSet();
+
+
+  int ff, np;
+  int dsize=decoder->getDataSize();
+  cout << " data size is " << dsize;
+  
+
+  char data[dsize];
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=atoi(argv[4]);
+  int runmax=atoi(argv[5]);
+  
+  char fname[10000];
+  char outfname[10000];
+  char imgfname[10000];
+  char pedfname[10000];
+  //  strcpy(pedfname,argv[6]);
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "fileformat is " << fformat << endl;
+  
+
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+ 
+
+
+
+
+
+
+
+  char* buff;
+  multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+
+ 
+  mt->setDetectorMode(ePhotonCounting);
+  mt->setFrameMode(eFrame);
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  cout << "mt " << endl;
+
+  int ifr=0;
+ 
+
+  for (int irun=runmin; irun<runmax; irun++) {
+    sprintf(fn,fformat,irun);
+    sprintf(fname,"%s/%s.raw",indir,fn);
+    sprintf(outfname,"%s/%s.clust",outdir,fn);
+    sprintf(imgfname,"%s/%s.tiff",outdir,fn);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    if (filebin.is_open()){
+      of=fopen(outfname,"w");
+      if (of) {
+  	mt->setFilePointer(of);
+	//	cout << "file pointer set " << endl;
+      } else {
+  	cout << "Could not open "<< outfname << " for writing " << endl;
+  	mt->setFilePointer(NULL);
+  	return 1;
+      }
+      //     //while read frame 
+      ff=-1;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	//	cout << "*"<<ifr++<<"*"<<ff<< endl;
+	//	cout << ff << " " << np << endl;
+  	//         //push
+	// for (int ix=0; ix<400; ix++)
+	//   for (int iy=0; iy<400; iy++) {
+	//     if (decoder->getChannel(buff, ix, iy)<3000 || decoder->getChannel(buff, ix, iy)>8000) {
+	//       cout <<  ifr << " " << ff << " " << ix << " " << iy << " " << decoder->getChannel(buff, ix, iy) << endl ;
+	//     }
+	//   }
+
+  	mt->pushData(buff);
+  // 	//         //pop
+  	mt->nextThread();
+  // // 		//	cout << " " << (void*)buff;
+  	mt->popFree(buff);
+	ifr++;
+	if (ifr%10000==0) cout << ifr << " " << ff << endl;
+	ff=-1;
+      }
+        cout << "--" << endl;
+      filebin.close();	 
+      //      //close file 
+      //     //join threads
+      while (mt->isBusy()) {;}//wait until all data are processed from the queues
+      if (of)
+  	fclose(of);
+      
+      mt->writeImage(imgfname);
+      mt->clearImage();
+   
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+
+    } else 
+     cout << "Could not open "<< fname << " for reading " << endl;
+      
+    
+  }
+    
+
+  return 0;
+}
+
--- a/slsDetectorCalibration/jungfrauExecutables/jungfrauInterpolation.cpp
+++ b/slsDetectorCalibration/jungfrauExecutables/jungfrauInterpolation.cpp
@ -0,0 +1,250 @@
+
+#include "sls/ansi.h"
+#include <iostream>
+
+//#include "moench03T1ZmqData.h"
+//#define DOUBLE_SPH
+//#define MANYFILES
+
+#ifdef DOUBLE_SPH
+#include "single_photon_hit_double.h"
+#endif
+
+#ifndef DOUBLE_SPH
+#include "single_photon_hit.h"
+#endif
+
+//#include "etaInterpolationPosXY.h"
+#include "noInterpolation.h"
+#include "etaInterpolationPosXY.h"
+//#include "etaInterpolationCleverAdaptiveBins.h"
+//#include "etaInterpolationRandomBins.h"
+using namespace std;
+#define NC 400
+#define NR 400
+#define MAX_ITERATIONS (nSubPixels*100)
+
+#define XTALK
+
+int main(int argc, char *argv[]) {
+
+#ifndef FF
+  if (argc<9) {
+    cout << "Wrong usage! Should be: "<< argv[0] << " infile  etafile outfile runmin runmax ns cmin cmax" << endl;
+    return 1;
+  }
+#endif
+  
+#ifdef FF
+  if (argc<7) {
+    cout << "Wrong usage! Should be: "<< argv[0] << " infile  etafile runmin runmax cmin cmax" << endl;
+    return 1;
+  }
+#endif
+  int iarg=4;
+  char infname[10000];
+  char fname[10000];
+  char outfname[10000];
+#ifndef FF
+  iarg=4;
+#endif
+
+#ifdef FF
+  iarg=3;
+#endif
+  int runmin=atoi(argv[iarg++]);
+  int runmax=atoi(argv[iarg++]); 
+  cout << "Run min: " << runmin << endl;
+  cout << "Run max: " << runmax << endl;
+  
+  int nsubpix=4;
+#ifndef FF
+  nsubpix=atoi(argv[iarg++]);
+  cout << "Subpix: " << nsubpix << endl;
+#endif
+  float cmin=atof(argv[iarg++]);
+  float cmax=atof(argv[iarg++]);
+  cout << "Energy min: " << cmin << endl;
+  cout << "Energy max: " << cmax << endl;
+  //int etabins=500;
+  int etabins=1000;//nsubpix*2*100;
+  double etamin=-1, etamax=2;
+  //double etamin=-0.1, etamax=1.1;
+  double eta3min=-2, eta3max=2;
+  int quad;
+  double sum, totquad;
+  double sDum[2][2];
+  double etax, etay, int_x, int_y;
+  double eta3x, eta3y, int3_x, int3_y, noint_x, noint_y;
+  int ok;
+  int f0=-1;
+  int ix, iy, isx, isy;
+  int nframes=0, lastframe=-1;
+  double d_x, d_y, res=5, xx, yy;
+  int nph=0, badph=0, totph=0;
+    FILE *f=NULL;
+
+#ifdef DOUBLE_SPH
+    single_photon_hit_double cl(3,3);
+#endif
+
+#ifndef DOUBLE_SPH
+    single_photon_hit cl(3,3);
+#endif
+
+    int nSubPixels=nsubpix;
+#ifndef NOINTERPOLATION
+   eta2InterpolationPosXY *interp=new eta2InterpolationPosXY(NC, NR, nsubpix, etabins, etamin, etamax);
+   //eta2InterpolationCleverAdaptiveBins *interp=new eta2InterpolationCleverAdaptiveBins(NC, NR, nsubpix, etabins, etamin, etamax);  
+#endif
+#ifdef NOINTERPOLATION
+    noInterpolation *interp=new noInterpolation(NC, NR, nsubpix);  
+#endif
+
+
+ 
+#ifndef FF
+#ifndef NOINTERPOLATION
+    cout << "read ff " << argv[2] << endl;
+    sprintf(fname,"%s",argv[2]);
+    interp->readFlatField(fname);
+    interp->prepareInterpolation(ok);//, MAX_ITERATIONS);
+#endif
+    // return 0;
+#endif
+#ifdef FF
+    cout << "Will write eta file " << argv[2] << endl;
+#endif
+
+    int *img;
+    float *totimg=new float[NC*NR*nsubpix*nsubpix];
+    for (ix=0; ix<NC; ix++) {
+      for (iy=0; iy<NR; iy++) {
+	for (isx=0; isx<nsubpix; isx++) {
+	  for (isy=0; isy<nsubpix; isy++) {
+	    totimg[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)]=0;
+	      }
+	}
+      }
+    }
+
+#ifdef FF
+      sprintf(outfname,argv[2]);
+#endif     
+
+    int irun;
+    for (irun=runmin; irun<runmax; irun++) {
+      sprintf(infname,argv[1],irun);
+#ifndef FF
+      sprintf(outfname,argv[3],irun);
+#endif
+ 
+      f=fopen(infname,"r");
+      if (f) {
+	cout << infname << endl;
+	nframes=0;
+	f0=-1;
+
+	while (cl.read(f)) {
+	  totph++;
+	  if (lastframe!=cl.iframe) {
+	    lastframe=cl.iframe;
+	    // cout << cl.iframe << endl;
+	    // f0=cl.iframe;
+	    if (nframes==0) f0=lastframe;
+	    nframes++;
+	  }
+	  //quad=interp->calcQuad(cl.get_cluster(), sum, totquad, sDum);
+	  quad=interp->calcEta(cl.get_cluster(), etax, etay, sum, totquad, sDum);
+	    if (sum>cmin && totquad/sum>0.8 && totquad/sum<1.2 && sum<cmax ) {
+	    nph++;
+	    //  if (sum>200 && sum<580) {
+	    //  interp->getInterpolatedPosition(cl.x,cl.y, totquad,quad,cl.get_cluster(),int_x, int_y);
+// #ifdef SOLEIL
+// 	    if (cl.x>210 && cl.x<240 && cl.y>210 && cl.y<240) {
+// #endif
+#ifndef FF
+	    // interp->getInterpolatedPosition(cl.x,cl.y, cl.get_cluster(),int_x, int_y);  
+	    interp->getInterpolatedPosition(cl.x,cl.y, etax, etay, quad,int_x, int_y);
+	      // cout <<"**************"<< endl;
+	      // cout << cl.x << " " << cl.y << " " << sum << endl;
+	      // cl.print();
+	      // cout << int_x << " " << int_y << endl;
+	      // cout <<"**************"<< endl;
+	    //  if (etax!=0 && etay!=0 && etax!=1 && etay!=1)
+	    interp->addToImage(int_x, int_y);
+	    if (int_x<0 || int_y<0 || int_x>400 || int_y>400) {
+	      cout <<"**************"<< endl;
+	      cout << cl.x << " " << cl.y << " " << sum << endl;
+	      cl.print();
+	      cout << int_x << " " << int_y << endl;
+	      cout <<"**************"<< endl;
+	    }
+#endif
+#ifdef FF
+	    //	interp->addToFlatField(cl.get_cluster(), etax, etay);
+// #ifdef UCL
+// 	    if (cl.x>50)
+// #endif
+// 	    if (etax!=0 && etay!=0 && etax!=1 && etay!=1)
+	      interp->addToFlatField(etax, etay);
+	    //  if (etax==0 || etay==0) cout << cl.x << " " << cl.y << endl;
+	     
+#endif
+// #ifdef SOLEIL
+// 	    }
+// #endif
+	    
+	    if (nph%1000000==0) cout << nph << endl;
+	    if (nph%10000000==0) { 
+#ifndef FF
+		interp->writeInterpolatedImage(outfname);
+#endif
+#ifdef FF 
+		interp->writeFlatField(outfname);
+#endif
+		
+		}
+	  }
+	    
+	} 
+	  
+	  
+	fclose(f);
+#ifdef FF
+	interp->writeFlatField(outfname);
+#endif
+	
+#ifndef FF
+	interp->writeInterpolatedImage(outfname); 
+
+	img=interp->getInterpolatedImage();
+	for (ix=0; ix<NC; ix++) {
+	  for (iy=0; iy<NR; iy++) {
+	    for (isx=0; isx<nsubpix; isx++) {
+	      for (isy=0; isy<nsubpix; isy++) {
+		totimg[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)]+=img[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)];
+		}
+	    }
+	  }
+	}
+	cout << "Read " << nframes << " frames (first frame: " << f0 << " last frame: " << lastframe << " delta:" << lastframe-f0 << ") nph="<< nph <<endl;
+	interp->clearInterpolatedImage();
+#endif
+	
+      } else
+	cout << "could not open file " << infname << endl;
+    }
+#ifndef FF
+    sprintf(outfname,argv[3],11111);
+    WriteToTiff(totimg, outfname,NC*nsubpix,NR*nsubpix);
+#endif 
+    
+#ifdef FF
+	interp->writeFlatField(outfname);
+#endif
+
+    cout << "Filled " << nph << " (/"<< totph <<") " << endl; 
+    return 0;
+}
+
--- a/slsDetectorCalibration/jungfrauExecutables/jungfrauPhotonCounter.cpp
+++ b/slsDetectorCalibration/jungfrauExecutables/jungfrauPhotonCounter.cpp
@ -0,0 +1,453 @@
+//#include "sls/ansi.h"
+#include <iostream>
+#define CORR
+
+#define C_GHOST 0.0004
+
+#define CM_ROWS 50
+
+//#define VERSION_V1
+
+//#include "moench03T1ZmqData.h"
+#ifdef NEWRECEIVER
+#ifndef RECT
+#include "moench03T1ReceiverDataNew.h"
+#endif
+
+#ifdef RECT
+#include "moench03T1ReceiverDataNewRect.h"
+#endif
+
+#endif
+
+
+#ifdef CSAXS_FP
+#include "moench03T1ReceiverData.h"
+#endif 
+#ifdef OLDDATA
+#include "moench03Ctb10GbT1Data.h"
+#endif 
+
+// #include "interpolatingDetector.h"
+//#include "etaInterpolationPosXY.h"
+// #include "linearInterpolation.h"
+// #include "noInterpolation.h"
+#include "multiThreadedCountingDetector.h"
+//#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+#include "moench03GhostSummation.h"
+#include "moench03CommonMode.h"
+//#include "interpolatingDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<4) {
+    cout << "Usage is " << argv[0] << "indir outdir fname [runmin] [runmax] [pedfile] [threshold] [nframes] [xmin xmax ymin ymax] [gainmap]" << endl;
+    cout << "threshold <0 means analog; threshold=0 means cluster finder; threshold>0 means photon counting" << endl;
+    cout << "nframes <0 means sum everything; nframes=0 means one file per run; nframes>0 means one file every nframes" << endl;
+    return 1;
+  }
+
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=10;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int save=1;
+  int nsigma=5;
+  int nped=10000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+  int cf=0;
+
+#ifdef NEWRECEIVER
+#ifdef RECT
+  cout << "Should be rectangular!" <<endl;
+#endif
+  moench03T1ReceiverDataNew *decoder=new  moench03T1ReceiverDataNew();
+  cout << "RECEIVER DATA WITH ONE HEADER!"<<endl;
+#endif
+
+#ifdef CSAXS_FP
+  moench03T1ReceiverData *decoder=new  moench03T1ReceiverData();
+  cout << "RECEIVER DATA WITH ALL HEADERS!"<<endl;
+#endif
+
+#ifdef OLDDATA
+  moench03Ctb10GbT1Data *decoder=new  moench03Ctb10GbT1Data();
+  cout << "OLD RECEIVER DATA!"<<endl;
+#endif
+
+  int nx=400, ny=400;
+
+  decoder->getDetectorSize(nx,ny);
+
+  int ncol_cm=CM_ROWS;
+  double xt_ghost=C_GHOST;
+  moench03CommonMode *cm=NULL;
+  moench03GhostSummation *gs;
+  double *gainmap=NULL;
+  float *gm;
+
+
+
+  int size = 327680;////atoi(argv[3]);
+  
+  int* image;
+	//int* image =new int[327680/sizeof(int)];
+
+  int ff, np;
+  //cout << " data size is " << dsize;
+  
+
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=0;
+  
+  // cout << "argc is " << argc << endl;
+ if (argc>=5) {
+   runmin=atoi(argv[4]);
+  }
+
+ int runmax=runmin;
+
+ if (argc>=6) {
+   runmax=atoi(argv[5]);
+  }
+
+  char *pedfile=NULL;
+  if (argc>=7) {
+    pedfile=argv[6];
+  }
+  double thr=0;
+  double thr1=1;
+
+  if (argc>=8) {
+    thr=atof(argv[7]);
+  }
+  
+
+  int nframes=0;
+  
+  if (argc>=9) {
+    nframes=atoi(argv[8]);
+  }
+
+  int xmin=0, xmax=nx, ymin=0, ymax=ny;
+  if (argc>=13) {
+    xmin=atoi(argv[9]);
+    xmax=atoi(argv[10]);
+    ymin=atoi(argv[11]);
+    ymax=atoi(argv[12]);
+  }
+
+  
+  char *gainfname=NULL;
+  if (argc>13) {
+    gainfname=argv[13];
+    cout << "Gain map file name is: " << gainfname << endl;
+  }
+
+  
+
+
+  char ffname[10000];
+  char fname[10000];
+  char imgfname[10000];
+  char cfname[10000];
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "input file is " << fformat << endl;
+  cout << "runmin is " << runmin << endl;
+  cout << "runmax is " << runmax << endl;
+  if (pedfile)
+    cout << "pedestal file is " << pedfile << endl;
+ if (thr>0) 
+    cout << "threshold is " << thr << endl;
+ cout << "Nframes is " << nframes << endl;
+ 
+ uint32 nnx, nny;
+ double *gmap;
+
+  // if (gainfname) {
+  //   gm=ReadFromTiff(gainfname, nny, nnx);
+  //   if (gm && nnx==nx && nny==ny) {
+  //     gmap=new double[nx*ny];
+  //     for (int i=0; i<nx*ny; i++) {
+  // 	gmap[i]=gm[i];
+  //     }
+  //     delete gm;
+  //   } else
+  //     cout << "Could not open gain map " << gainfname << endl;
+  // }
+
+#ifdef CORR
+ cout << "Applying common mode  " << ncol_cm << endl;
+  cm=new moench03CommonMode(ncol_cm);
+  
+
+  cout << "Applying ghost corrections " << xt_ghost << endl;
+  gs=new moench03GhostSummation(decoder, xt_ghost);
+#endif
+
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, cm, nped, 200, -1, -1, gainmap, gs);
+
+  if (gainfname) {
+
+    if (filter->readGainMap(gainfname))
+      cout << "using gain map " << gainfname << endl;
+    else
+      cout << "Could not open gain map " << gainfname << endl;
+  } else
+    thr=0.15*thr;
+  filter->newDataSet();
+  int dsize=decoder->getDataSize();
+
+
+  char data[dsize];
+
+
+
+
+
+  //#ifndef ANALOG
+  if (thr>0) {
+    cout << "threshold is " << thr << endl;
+    //#ifndef ANALOG
+    filter->setThreshold(thr);
+    //#endif
+      cf=0;
+
+  } else
+    cf=1;
+  //#endif
+
+
+  filter->setROI(xmin,xmax,ymin,ymax);
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+
+  char* buff;
+
+  // multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+ multiThreadedCountingDetector *mt=new multiThreadedCountingDetector(filter,nthreads,fifosize);
+#ifndef ANALOG
+    mt->setDetectorMode(ePhotonCounting);
+    cout << "Counting!" << endl;
+  if (thr>0) {
+    cf=0;
+  } 
+#endif
+//{
+#ifdef ANALOG
+      mt->setDetectorMode(eAnalog);
+      cout << "Analog!" << endl;
+      cf=0;
+      //thr1=thr;
+#endif  
+      //  }
+  
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  //  cout << "mt " << endl;
+
+  int ifr=0;
+
+  double ped[nx*ny], *ped1;
+
+
+  if (pedfile) {
+
+    cout << "PEDESTAL " << endl;
+    sprintf(imgfname,"%s/pedestals.tiff",outdir);
+
+    if (string(pedfile).find(".tif")==std::string::npos){
+      sprintf(fname,"%s.raw",pedfile);
+      cout << fname << endl ;
+      std::time(&end_time);
+      cout << "aaa" << std::ctime(&end_time) <<   endl;
+      
+      
+      mt->setFrameMode(ePedestal);
+      // sprintf(fn,fformat,irun);
+      filebin.open((const char *)(fname), ios::in | ios::binary);
+      //      //open file
+      if (filebin.is_open()){
+	ff=-1;
+	while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	  if (np==40) {
+	    mt->pushData(buff);
+	    mt->nextThread();
+	    mt->popFree(buff);
+	    ifr++;
+	    if (ifr%100==0) 
+	      cout << ifr << " " << ff << " " << np << endl;
+	  } else
+	    cout << ifr << " " << ff << " " << np << endl;
+	  ff=-1;
+	}
+	filebin.close();	 
+	while (mt->isBusy()) {;}
+	
+      } else 
+	cout << "Could not open pedestal file "<< fname << " for reading " << endl;
+    } else {
+      float *pp=ReadFromTiff(pedfile, nny, nnx);
+      if (pp && nnx==nx && nny==ny) {
+	for (int i=0; i<nx*ny; i++) {
+	  ped[i]=pp[i];
+	}
+	delete [] pp;
+	mt->setPedestal(ped);
+	// ped1=mt->getPedestal();
+	
+	// for (int i=0; i<nx*ny; i++) {
+
+	//   cout << ped[i]<<"/"<<ped1[i] << " " ;
+	// }
+	cout << "Pedestal set from tiff file " << pedfile << endl;
+      } else {
+	cout << "Could not open pedestal tiff file "<< pedfile << " for reading " << endl;
+      }
+    }
+    mt->writePedestal(imgfname);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<   endl;
+  }
+  
+
+
+  ifr=0;
+  int ifile=0;
+  
+  mt->setFrameMode(eFrame);
+
+  for (int irun=runmin; irun<=runmax; irun++) {
+    cout << "DATA " ;
+    // sprintf(fn,fformat,irun);
+    sprintf(ffname,"%s/%s.raw",indir,fformat);
+    sprintf(fname,ffname,irun);
+    sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+    sprintf(imgfname,ffname,irun);
+    sprintf(ffname,"%s/%s.clust",outdir,fformat);
+    sprintf(cfname,ffname,irun);
+    cout << fname << " " ;
+    cout << imgfname << endl;
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    //  cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    ifile=0;
+    if (filebin.is_open()){
+      if (thr<=0 && cf!=0) { //cluster finder
+	  if (of==NULL) {
+	    of=fopen(cfname,"w");
+	    if (of) {
+	    mt->setFilePointer(of);
+	    cout << "file pointer set " << endl;
+	    } else {
+	      cout << "Could not open "<< cfname << " for writing " << endl;
+	      mt->setFilePointer(NULL);
+	      return 1;
+	    }
+	  }
+      }
+      //     //while read frame 
+      ff=-1;
+      ifr=0;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	if (np==40) {
+	//	cout << "*"<<ifr++<<"*"<<ff<< endl;
+	//	cout << ff << " " << np << endl;
+  	//         //push
+	  mt->pushData(buff);
+	  // 	//         //pop
+	  mt->nextThread();
+	  // // 		//	cout << " " << (void*)buff;
+	  mt->popFree(buff);
+
+
+
+
+	  ifr++;
+	  if (ifr%100==0) cout << ifr << " " << ff << endl;
+	  if (nframes>0) {
+	    if (ifr%nframes==0) {
+	      //The name has an additional "_fXXXXX" at the end, where "XXXXX" is the initial frame number of the image (0,1000,2000...)
+	      
+	      sprintf(ffname,"%s/%s_f%05d.tiff",outdir,fformat,ifile);
+	      sprintf(imgfname,ffname,irun);
+	      //cout << "Writing tiff to " << imgfname << " " << thr1 << endl;
+	      mt->writeImage(imgfname, thr1);
+	      mt->clearImage();
+	      ifile++;
+	    }
+	  }
+	} else
+	  cout << ifr << " " << ff << " " << np << endl;
+	ff=-1;
+      }
+      cout << "--" << endl;
+      filebin.close();	 
+      //      //close file 
+      //     //join threads
+      while (mt->isBusy()) {;}
+      if (nframes>=0) {
+	if (nframes>0) {
+	    sprintf(ffname,"%s/%s_f%05d.tiff",outdir,fformat,ifile);
+	    sprintf(imgfname,ffname,irun);
+	} else {
+	  sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+	  sprintf(imgfname,ffname,irun);
+	}
+	cout << "Writing tiff to " << imgfname << " " << thr1 <<endl;
+	mt->writeImage(imgfname, thr1);
+	mt->clearImage();
+	if (of) {
+	  fclose(of);
+	  of=NULL;
+	  mt->setFilePointer(NULL);
+	}
+      }	
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+    } else 
+      cout << "Could not open "<< fname << " for reading " << endl;
+  }
+  if (nframes<0){
+    sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+    strcpy(imgfname,ffname);
+    cout << "Writing tiff to " << imgfname << " " << thr1 <<endl;
+    mt->writeImage(imgfname, thr1);
+  }
+    
+
+
+  return 0;
+}
+
--- a/slsDetectorCalibration/jungfrauExecutables/jungfrauZmqProcess.cpp
+++ b/slsDetectorCalibration/jungfrauExecutables/jungfrauZmqProcess.cpp
--- a/slsDetectorCalibration/moenchExecutables/CMakeLists.txt
+++ b/slsDetectorCalibration/moenchExecutables/CMakeLists.txt
@ -3,11 +3,11 @@ find_package(TIFF REQUIRED)

 #Moench ZMQ
 add_executable(moenchZmqProcess moenchZmqProcess.cpp ../tiffIO.cpp)
-add_compile_definitions(moenchZmqProcess NEWZMQ INTERP)
+target_compile_definitions(moenchZmqProcess PRIVATE NEWZMQ INTERP)

 #Moench04 ZMQ
 add_executable(moench04ZmqProcess moenchZmqProcess.cpp ../tiffIO.cpp)
-add_compile_definitions(moenchZmqProcess NEWZMQ INTERP MOENCH04)
+target_compile_definitions(moench04ZmqProcess PRIVATE NEWZMQ INTERP MOENCH04)


 #Both executables should have the same includes and output dirs
--- a/slsDetectorCalibration/moenchExecutables/moenchZmqProcess.cpp
+++ b/slsDetectorCalibration/moenchExecutables/moenchZmqProcess.cpp
@ -1,6 +1,8 @@
 //#define WRITE_QUAD
 #define DEVELOPER
 #undef CORR
+#undef MOENCH04
+
 #define C_GHOST 0.0004

 #define CM_ROWS 20
@ -28,6 +30,7 @@
 #include <fstream> 
 #include "tiffIO.h"

+
 #include <rapidjson/document.h> //json header in zmq stream

 #include<iostream>
@ -135,9 +138,11 @@ int main(int argc, char *argv[]) {

  //slsDetectorData *det=new moench03T1ZmqDataNew(); 
 #ifndef MOENCH04
+  cout << "This is a Moench03" << endl;
  moench03T1ZmqDataNew *det=new moench03T1ZmqDataNew(); 
 #endif
 #ifdef MOENCH04
+  cout << "This is a Moench04" << endl;
  moench04CtbZmq10GbData *det=new moench04CtbZmq10GbData(); 
 #endif
  cout << endl << " det" <<endl;
@ -614,61 +619,8 @@ int main(int argc, char *argv[]) {
 	      version=zHeader.version;//doc["version"].GetUint();
 	      /*document["bitmode"].GetUint(); zHeader.dynamicRange

-document["fileIndex"].GetUint64(); zHeader.fileIndex

-document["detshape"][0].GetUint();
-zHeader.ndetx
-
-document["detshape"][1].GetUint();
-zHeader.ndety
-
-document["shape"][0].GetUint();
-zHeader.npixelsx
-
-document["shape"][1].GetUint();
-zHeader.npixelsy
-
-document["size"].GetUint(); zHeader.imageSize
-
-document["acqIndex"].GetUint64(); zHeader.acqIndex
-
-document["frameIndex"].GetUint64(); zHeader.frameIndex
-
-document["fname"].GetString(); zHeader.fname
-
-document["frameNumber"].GetUint64(); zHeader.frameNumber
-
-document["expLength"].GetUint(); zHeader.expLength
-
-document["packetNumber"].GetUint(); zHeader.packetNumber
-
-document["bunchId"].GetUint64(); zHeader.bunchId
-
-document["timestamp"].GetUint64(); zHeader.timestamp
-
-document["modId"].GetUint(); zHeader.modId
-
-document["row"].GetUint(); zHeader.row
-
-document["column"].GetUint(); zHeader.column
-
-document["reserved"].GetUint(); zHeader.reserved
-
-document["debug"].GetUint(); zHeader.debug
-
-document["roundRNumber"].GetUint(); zHeader.roundRNumber
-
-document["detType"].GetUint(); zHeader.detType
-
-document["version"].GetUint(); zHeader.version
-
-document["flippedDataX"].GetUint(); zHeader.flippedDataX
-
-document["quad"].GetUint(); zHeader.quad
-
-document["completeImage"].GetUint(); zHeader.completeImage
 	      */
-	      //dataSize=size;

 	      //strcpy(fname,filename.c_str());
 	      fname=filename;
--- a/slsDetectorCalibration/multiThreadedAnalogDetector.h
+++ b/slsDetectorCalibration/multiThreadedAnalogDetector.h
@ -17,7 +17,7 @@
 #include <pthread.h>

 #include "analogDetector.h"
-#include "sls/CircularFifo.h"
+#include "circularFifo.h"
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
@ -123,7 +123,7 @@ public:
     return fifoFree->pop(ptr);
   }

-   virtual int isBusy() {if (fifoData->isEmpty() && busy==0) return 0; else return 1;}
+   virtual int isBusy() {if (fifoData->isEmpty() && busy==0) return 0; return 1;}
   
   //protected:
   /** Implement this method in your subclass with the code you want your thread to run. */
--- a/slsDetectorGui/CMakeLists.txt
+++ b/slsDetectorGui/CMakeLists.txt
@ -91,7 +91,6 @@ target_include_directories(slsDetectorGui PUBLIC

 target_link_libraries(slsDetectorGui PUBLIC
    slsProjectOptions 
-    slsProjectWarnings
    slsDetectorStatic
    ${QT_QTCORE_LIBRARIES}
    ${QT_QTGUI_LIBRARIES}
@ -101,6 +100,9 @@ target_link_libraries(slsDetectorGui PUBLIC
    Qt4::QtOpenGL
    Qt4::QtSvg
    expat
+    
+    PRIVATE
+    slsProjectWarnings
 )

 set_target_properties(slsDetectorGui PROPERTIES
@ -111,7 +113,7 @@ if(SLS_LTO_AVAILABLE)
 endif()

 install(TARGETS slsDetectorGui
-    EXPORT "${TARGETS_EXPORT_NAME}"
+    # EXPORT "${TARGETS_EXPORT_NAME}" #do not export gui
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
--- a/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer
+++ b/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer
--- a/slsDetectorServers/eigerDetectorServer/FebControl.c
+++ b/slsDetectorServers/eigerDetectorServer/FebControl.c
@ -1395,7 +1395,7 @@ int Feb_Control_SetMaster(enum MASTERINDEX ind) {
 int Feb_Control_SetQuad(int val) {
    LOG(logINFO, ("Setting Quad to %d in Feb\n", val));
    // only setting on the right feb if quad
-    return Feb_Control_SetTop(val == 0 ? TOP_HARDWARE : OW_TOP, 0, 1);
+    return Feb_Control_SetTop(val == 0 ? TOP_HARDWARE : OW_BOTTOM, 0, 1);
 }

 int Feb_Control_SetReadNLines(int value) {
--- a/slsDetectorServers/eigerDetectorServer/bin/config_eiger.txt
+++ b/slsDetectorServers/eigerDetectorServer/bin/config_eiger.txt
@ -0,0 +1,2 @@
+top 1
+master 1
--- a/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
+++ b/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
--- a/slsDetectorServers/eigerDetectorServer/bin/hv9m_blackfin_serverv3.0.0.1
+++ b/slsDetectorServers/eigerDetectorServer/bin/hv9m_blackfin_serverv3.0.0.1
--- a/slsDetectorServers/gotthard2DetectorServer/bin/config_gotthard2.txt
+++ b/slsDetectorServers/gotthard2DetectorServer/bin/config_gotthard2.txt
@ -0,0 +1,33 @@
+
+
+#onchip dacs        chip index   value (max 0x3ff)
+vchip_comp_fe       -1          0x137
+vchip_opa_1st       -1          0x000
+vchip_opa_fd        -1          0x134
+vchip_comp_adc      -1          0x3FF   
+vchip_ref_comp_fe   -1          0x180
+vchip_cs            -1          0x0D0
+
+#dacs           value (max 4096)
+vref_h_adc      2116
+vb_comp_fe      0
+vb_comp_adc     0
+vcom_cds        705
+vref_rstore     150
+vb_opa_1st      0
+vref_comp_fe    0
+vcom_adc1       705
+vref_prech      869
+vref_l_adc      700
+vref_cds        700
+vb_cs           2799
+vb_opa_fd       0
+vcom_adc2       704
+
+#configure adc  chip index      adc index   value(max 0x7F)
+confadc         -1              -1          0x22
+
+#vetoreference  gain index  value(max 4095)
+vetoref         1           0
+
+
--- a/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer
+++ b/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer
--- a/slsDetectorServers/gotthardDetectorServer/bin/config_gotthard.txt
+++ b/slsDetectorServers/gotthardDetectorServer/bin/config_gotthard.txt
@ -0,0 +1,23 @@
+#masterflags (no_master, is_master, is_slave)
+masterflags no_master
+
+#master default delay 
+masterdefaultdelay 70
+
+#patternphase 
+patternphase 0
+
+#adcphase 
+adcphase 0
+
+#slave pattern phase
+slavepatternphase 0
+
+#slave adc phase 
+slaveadcphase 0
+
+#rst to sw1 delay
+rsttosw1delay 2
+
+#start acquisition delay
+startacqdelay 1
--- a/slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer
+++ b/slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer
--- a/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer
+++ b/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer
--- a/slsDetectorServers/moenchDetectorServer/bin/DefaultPattern_moench.txt
+++ b/slsDetectorServers/moenchDetectorServer/bin/DefaultPattern_moench.txt
@ -0,0 +1,288 @@
+patword 0x0000 0x0008599f0418503a
+patword 0x0001 0x0008599f0418503a
+patword 0x0002 0x000859960418503a
+patword 0x0003 0x000859960418503a
+patword 0x0004 0x000859960418503a
+patword 0x0005 0x000859960418503a
+patword 0x0006 0x000859960418503a
+patword 0x0007 0x000859960418503a
+patword 0x0008 0x000859960418503a
+patword 0x0009 0x000859960418503a
+patword 0x000a 0x000859960418503a
+patword 0x000b 0x000859960418503a
+patword 0x000c 0x000859960418503a
+patword 0x000d 0x000859960418503a
+patword 0x000e 0x000859960418503a
+patword 0x000f 0x000859960418503a
+patword 0x0010 0x000859960418503a
+patword 0x0011 0x000859960418503a
+patword 0x0012 0x000859960418503a
+patword 0x0013 0x000859960418503a
+patword 0x0014 0x000859960418503a
+patword 0x0015 0x000859960418503a
+patword 0x0016 0x000819960418501a
+patword 0x0017 0x000819960418501a
+patword 0x0018 0x000819960418501a
+patword 0x0019 0x000819960418501a
+patword 0x001a 0x000819960418501a
+patword 0x001b 0x000819960418501a
+patword 0x001c 0x000819960418501a
+patword 0x001d 0x000819960418501a
+patword 0x001e 0x000819960418501a
+patword 0x001f 0x000819960418501a
+patword 0x0020 0x000819960418501a
+patword 0x0021 0x000819960418501a
+patword 0x0022 0x000819960418501a
+patword 0x0023 0x000819960418501a
+patword 0x0024 0x000819960418501a
+patword 0x0025 0x000819960418501a
+patword 0x0026 0x000819960418501a
+patword 0x0027 0x000819960418501a
+patword 0x0028 0x000819960418501a
+patword 0x0029 0x000819960418501a
+patword 0x002a 0x000819960418501a
+patword 0x002b 0x000819960418501a
+patword 0x002c 0x000819960418501a
+patword 0x002d 0x000819960418501a
+patword 0x002e 0x000819960418501a
+patword 0x002f 0x000819960418501a
+patword 0x0030 0x000819960008501a
+patword 0x0031 0x000819960008501a
+patword 0x0032 0x000819960008501a
+patword 0x0033 0x000819960008501a
+patword 0x0034 0x000819960008501a
+patword 0x0035 0x000819960008501a
+patword 0x0036 0x000819960008501a
+patword 0x0037 0x000819960008501a
+patword 0x0038 0x000819960008501a
+patword 0x0039 0x000819960008501a
+patword 0x003a 0x000819960008501a
+patword 0x003b 0x000819960008501a
+patword 0x003c 0x000819960008501a
+patword 0x003d 0x000819960008501a
+patword 0x003e 0x000819960008501a
+patword 0x003f 0x000819960008501a
+patword 0x0040 0x000819960008501a
+patword 0x0041 0x000819960008501a
+patword 0x0042 0x000819960008501a
+patword 0x0043 0x000819960008501a
+patword 0x0044 0x0008199f0008501a
+patword 0x0045 0x0008199f0008501a
+patword 0x0046 0x0008199f0008501a
+patword 0x0047 0x0008199f0008501a
+patword 0x0048 0x0008199f0008501a
+patword 0x0049 0x0008199f0008501a
+patword 0x004a 0x0008199f0008501a
+patword 0x004b 0x0008199f0008501a
+patword 0x004c 0x0008199f0008501a
+patword 0x004d 0x0008199f0008501a
+patword 0x004e 0x0008199f0008501a
+patword 0x004f 0x0008199f0008501a
+patword 0x0050 0x0008199f0008501a
+patword 0x0051 0x0008199f0008501a
+patword 0x0052 0x0008199f0008501a
+patword 0x0053 0x0008199f0008501a
+patword 0x0054 0x0008199f0008501a
+patword 0x0055 0x0008199f0008501a
+patword 0x0056 0x0008199f0008501a
+patword 0x0057 0x0008199f0008501a
+patword 0x0058 0x0008599f0008503a
+patword 0x0059 0x0008599f0008503a
+patword 0x005a 0x000c599f000850ba
+patword 0x005b 0x000c599f000850ba
+patword 0x005c 0x000c599f000850ba
+patword 0x005d 0x000c599f000850ba
+patword 0x005e 0x000c599f000850ba
+patword 0x005f 0x000c599f000850ba
+patword 0x0060 0x000c599f000850ba
+patword 0x0061 0x000c599f000850ba
+patword 0x0062 0x000c599f000850ba
+patword 0x0063 0x000c599f000850ba
+patword 0x0064 0x000c599f000850ba
+patword 0x0065 0x000c599f000850ba
+patword 0x0066 0x000c599f000850ba
+patword 0x0067 0x000c599f000850ba
+patword 0x0068 0x000c599f000850ba
+patword 0x0069 0x000c599f000850ba
+patword 0x006a 0x000c599f000850ba
+patword 0x006b 0x000c599f000850ba
+patword 0x006c 0x000c599f000850ba
+patword 0x006d 0x000c599f000850ba
+patword 0x006e 0x000c799f010858ba
+patword 0x006f 0x000c799f010858ba
+patword 0x0070 0x000c599f000850ba
+patword 0x0071 0x000c599f000850ba
+patword 0x0072 0x000c599f000850ba
+patword 0x0073 0x000c599f000850ba
+patword 0x0074 0x000c599f000850ba
+patword 0x0075 0x000c599f000850ba
+patword 0x0076 0x000c599f000850ba
+patword 0x0077 0x000c599f000850ba
+patword 0x0078 0x000c599f000850ba
+patword 0x0079 0x000c599f000850ba
+patword 0x007a 0x000c599f000850ba
+patword 0x007b 0x000c599f000850ba
+patword 0x007c 0x000c599f000850ba
+patword 0x007d 0x000c599f000850ba
+patword 0x007e 0x000c599f000850ba
+patword 0x007f 0x000c599f000850ba
+patword 0x0080 0x000c599f000850ba
+patword 0x0081 0x000c599f000850ba
+patword 0x0082 0x000c599f000850ba
+patword 0x0083 0x000c599f000850ba
+patword 0x0084 0x000c599f000850ba
+patword 0x0085 0x000c599f000850ba
+patword 0x0086 0x000c599f400850ba
+patword 0x0087 0x000c599f400850ba
+patword 0x0088 0x000c599f600850ba
+patword 0x0089 0x000c599f400850ba
+patword 0x008a 0x000c599f400850ba
+patword 0x008b 0x000c599f400850ba
+patword 0x008c 0x840c599f682e50ba
+patword 0x008d 0x840c599f482850ba
+patword 0x008e 0x840c599f000e50ba
+patword 0x008f 0x840c599f000850ba
+patword 0x0090 0x840c599f000e50ba
+patword 0x0091 0x840c599f000850ba
+patword 0x0092 0x840c599f000e50ba
+patword 0x0093 0x840c599f000850ba
+patword 0x0094 0x840c599f000e50ba
+patword 0x0095 0x840c599f000850ba
+patword 0x0096 0x840c599f000e50ba
+patword 0x0097 0x840c599f000850ba
+patword 0x0098 0x840c599f000e50ba
+patword 0x0099 0x840c599f000850ba
+patword 0x009a 0x840c599f000e50ba
+patword 0x009b 0x840c599f000850ba
+patword 0x009c 0x840c599f000e50ba
+patword 0x009d 0x840c599f000850ba
+patword 0x009e 0x840c599f000e50ba
+patword 0x009f 0x840c599f000850ba
+patword 0x00a0 0x840c599f000e50ba
+patword 0x00a1 0x840c599f000850ba
+patword 0x00a2 0x840c599f000e50ba
+patword 0x00a3 0x840c599f000850ba
+patword 0x00a4 0x840c599f000e50ba
+patword 0x00a5 0x840c599f000850ba
+patword 0x00a6 0x840c599f200e50ba
+patword 0x00a7 0x840c599f000850ba
+patword 0x00a8 0x840c599f000e50ba
+patword 0x00a9 0x840c599f000850ba
+patword 0x00aa 0x840c599f000e50ba
+patword 0x00ab 0x840c599f000850ba
+patword 0x00ac 0x840c599f000e50ba
+patword 0x00ad 0x840c599f000850ba
+patword 0x00ae 0x840c599f000e50ba
+patword 0x00af 0x840c599f000850ba
+patword 0x00b0 0x840c599f000e50ba
+patword 0x00b1 0x840c599f000850ba
+patword 0x00b2 0x840c599f000e50ba
+patword 0x00b3 0x840c599f000850ba
+patword 0x00b4 0x840c599f000e50ba
+patword 0x00b5 0x840c599f000850ba
+patword 0x00b6 0x840c599f000e50ba
+patword 0x00b7 0x840c599f000850ba
+patword 0x00b8 0x840c599f000e50ba
+patword 0x00b9 0x840c599f000850ba
+patword 0x00ba 0x840c599f000e50ba
+patword 0x00bb 0x840c599f000850ba
+patword 0x00bc 0x840c599f000e50ba
+patword 0x00bd 0x840c599f000850ba
+patword 0x00be 0x840c599f282e50ba
+patword 0x00bf 0x840c599f082850ba
+patword 0x00c0 0x840c599f000e50ba
+patword 0x00c1 0x840c599f000850ba
+patword 0x00c2 0x840c599f000e50ba
+patword 0x00c3 0x840c599f000850ba
+patword 0x00c4 0x840c599f000e50ba
+patword 0x00c5 0x840c599f000850ba
+patword 0x00c6 0x840c599f000e50ba
+patword 0x00c7 0x840c599f000850ba
+patword 0x00c8 0x840c599f000e50ba
+patword 0x00c9 0x840c599f000850ba
+patword 0x00ca 0x840c599f000e50ba
+patword 0x00cb 0x840c599f000850ba
+patword 0x00cc 0x840c599f000e50ba
+patword 0x00cd 0x840c599f000850ba
+patword 0x00ce 0x840c599f000e50ba
+patword 0x00cf 0x840c599f000850ba
+patword 0x00d0 0x840c599f000e50ba
+patword 0x00d1 0x840c599f000850ba
+patword 0x00d2 0x840c599f000e50ba
+patword 0x00d3 0x840c599f000850ba
+patword 0x00d4 0x840c599f000e50ba
+patword 0x00d5 0x840c599f000850ba
+patword 0x00d6 0x840c599f000e50ba
+patword 0x00d7 0x840c599f000850ba
+patword 0x00d8 0x840c599f200e50ba
+patword 0x00d9 0x840c599f000850ba
+patword 0x00da 0x840c599f000e50ba
+patword 0x00db 0x840c599f000850ba
+patword 0x00dc 0x840c599f000e50ba
+patword 0x00dd 0x840c599f000850ba
+patword 0x00de 0x840c599f000e50ba
+patword 0x00df 0x840c599f000850ba
+patword 0x00e0 0x840c599f000e50ba
+patword 0x00e1 0x840c599f000850ba
+patword 0x00e2 0x840c599f000e50ba
+patword 0x00e3 0x840c599f000850ba
+patword 0x00e4 0x840c599f000e50ba
+patword 0x00e5 0x840c599f000850ba
+patword 0x00e6 0x840c599f000e50ba
+patword 0x00e7 0x840c599f000850ba
+patword 0x00e8 0x840c599f000e50ba
+patword 0x00e9 0x840c599f000850ba
+patword 0x00ea 0x840c599f000e50ba
+patword 0x00eb 0x840c599f000850ba
+patword 0x00ec 0x840c599f000e50ba
+patword 0x00ed 0x840c599f000850ba
+patword 0x00ee 0x840c599f000e50ba
+patword 0x00ef 0x840c599f000850ba
+patword 0x00f0 0x040c599f000850ba
+patword 0x00f1 0x040c599f000850ba
+patword 0x00f2 0x000c599f000850ba
+patword 0x00f3 0x000c599f000850ba
+patword 0x00f4 0x0008599f200e503a
+patword 0x00f5 0x0008599f0008503a
+patword 0x00f6 0x0008599f200e503a
+patword 0x00f7 0x0008599f0008503a
+patword 0x00f8 0x0008599f0008503a
+patword 0x00f9 0x0008599f0008503a
+patword 0x00fa 0x0008599f0008503a
+patword 0x00fb 0x0008599f0008503a
+patword 0x00fc 0x0008599f0008503a
+patword 0x00fd 0x0008599f0008503a
+patword 0x00fe 0x0008599f0008503a
+patword 0x00ff 0x0008599f0008503a
+patword 0x0100 0x0008599f0008503a
+patword 0x0101 0x0008599f0008503a
+patword 0x0102 0x0008599f0008503a
+patword 0x0103 0x0008599f0008503a
+patword 0x0104 0x0008599f0008503a
+patword 0x0105 0x0008599f0008503a
+patword 0x0106 0x0008599f0008503a
+patword 0x0107 0x0008599f0008503a
+patword 0x0108 0x0008599f0008503a
+patword 0x0109 0x0008599f0008503a
+patword 0x010a 0x0008599f0008503a
+patword 0x010b 0x0008599f0008503a
+patword 0x010c 0x0008599f0008503a
+patword 0x010d 0x0008599f0008503a
+patword 0x010e 0x0008599f0008503a
+patword 0x010f 0x0008599f0008503a
+patword 0x0110 0x0008599f0008503a
+patword 0x0111 0x0008599f0008503a
+patioctrl 0x8f0effff6dbffdbf
+patlimits 0x0000 0x0110
+patloop0 0x00be 0x00ef
+patnloop0 199
+patloop1 0x0400 0x0400
+patnloop1 0
+patloop2 0x0400 0x0400
+patnloop2 0
+patwait0 0x002e
+patwaittime0 800
+patwait1 0x0400
+patwaittime1 0
+patwait2 0x0400
+patwaittime2 0
--- a/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer
+++ b/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer
--- a/slsDetectorServers/mythen3DetectorServer/CMakeLists.txt
+++ b/slsDetectorServers/mythen3DetectorServer/CMakeLists.txt
@ -1,5 +1,6 @@
 add_executable(mythen3DetectorServer_virtual
    slsDetectorFunctionList.c
+    mythen3.c
    ../slsDetectorServer/src/slsDetectorServer.c
    ../slsDetectorServer/src/slsDetectorServer_funcs.c
    ../slsDetectorServer/src/communication_funcs.c
@ -10,7 +11,8 @@ add_executable(mythen3DetectorServer_virtual
    ../slsDetectorServer/src/LTC2620_Driver.c
    ../slsDetectorServer/src/ALTERA_PLL_CYCLONE10.c   
    ../slsDetectorServer/src/programFpgaNios.c
-    ../slsDetectorServer/src/readDefaultPattern.c         
+    ../slsDetectorServer/src/readDefaultPattern.c 
+    ../slsDetectorServer/src/loadPattern.c         
    ../slsDetectorServer/src/sharedMemory.c
 )

--- a/slsDetectorServers/mythen3DetectorServer/Makefile
+++ b/slsDetectorServers/mythen3DetectorServer/Makefile
@ -13,7 +13,7 @@ DESTDIR		?= 	bin
 INSTMODE	= 	0777

 SRCS	=	slsDetectorFunctionList.c 
-SRCS	+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)nios.c $(main_src)DAC6571.c $(main_src)common.c $(main_src)LTC2620_Driver.c $(main_src)ALTERA_PLL_CYCLONE10.c $(main_src)/programFpgaNios.c $(main_src)readDefaultPattern.c $(main_src)/sharedMemory.c
+SRCS	+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)nios.c $(main_src)DAC6571.c $(main_src)common.c $(main_src)LTC2620_Driver.c $(main_src)ALTERA_PLL_CYCLONE10.c $(main_src)/programFpgaNios.c $(main_src)readDefaultPattern.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c mythen3.c

 OBJS 	= 	$(SRCS:.c=.o) 
 
@ -40,4 +40,4 @@ clean:
 	rm -rf $(DESTDIR)/$(PROGS)  *.o *.gdb $(main_src)*.o
 	

-	
+	
--- a/slsDetectorServers/mythen3DetectorServer/bin/DefaultPattern_mythen3.txt
+++ b/slsDetectorServers/mythen3DetectorServer/bin/DefaultPattern_mythen3.txt
@ -0,0 +1,256 @@
+patword 0x0000 0x0000000000000000
+patword 0x0001 0x0000000000000000
+patword 0x0002 0x0000000000000000
+patword 0x0003 0x0000000000000000
+patword 0x0004 0x0000000000000000
+patword 0x0005 0x0000000000000000
+patword 0x0006 0x0000000000c00000
+patword 0x0007 0x0000000000c00000
+patword 0x0008 0x0000000000c00000
+patword 0x0009 0x0000000000c00000
+patword 0x000a 0x0000000000c00000
+patword 0x000b 0x0000000000c00000
+patword 0x000c 0x0000000000000000
+patword 0x000d 0x0000000000000000
+patword 0x000e 0x0000000000000000
+patword 0x000f 0x0000000000000000
+patword 0x0010 0x0000000000000000
+patword 0x0011 0x0000000000000000
+patword 0x0012 0x0000000000200000
+patword 0x0013 0x0000000000200000
+patword 0x0014 0x0000000000e00000
+patword 0x0015 0x0000000000e00000
+patword 0x0016 0x0000000000e00000
+patword 0x0017 0x0000000000e00000
+patword 0x0018 0x0000000000e00000
+patword 0x0019 0x0000000000e00000
+patword 0x001a 0x0000000000e00000
+patword 0x001b 0x0000000000e00000
+patword 0x001c 0x0000000000200000
+patword 0x001d 0x0000000000200000
+patword 0x001e 0x0000000000200000
+patword 0x001f 0x0000000000200000
+patword 0x0020 0x0000000000200000
+patword 0x0021 0x0000000000200000
+patword 0x0022 0x0000000000200000
+patword 0x0023 0x0000000000200000
+patword 0x0024 0x0000000000200000
+patword 0x0025 0x0000000000200000
+patword 0x0026 0x0000000000200000
+patword 0x0027 0x0000000000200000
+patword 0x0028 0x0000000000200000
+patword 0x0029 0x0000000001200000
+patword 0x002a 0x0000000000200000
+patword 0x002b 0x0000000000200000
+patword 0x002c 0x0000000000200000
+patword 0x002d 0x0000000000200000
+patword 0x002e 0x0000000000200000
+patword 0x002f 0x0000000000200000
+patword 0x0030 0x0000000000200000
+patword 0x0031 0x0000000000200000
+patword 0x0032 0x0000000001200000
+patword 0x0033 0x0000000000200000
+patword 0x0034 0x0000000000200000
+patword 0x0035 0x0000000000200000
+patword 0x0036 0x0000000000200000
+patword 0x0037 0x0000000000200000
+patword 0x0038 0x0000000000200000
+patword 0x0039 0x0000000000200000
+patword 0x003a 0x0000000000200000
+patword 0x003b 0x0000000001200000
+patword 0x003c 0x0000000000200000
+patword 0x003d 0x0000000000200000
+patword 0x003e 0x0000000000200000
+patword 0x003f 0x0000000000200000
+patword 0x0040 0x0000000000200000
+patword 0x0041 0x0000000000200000
+patword 0x0042 0x0000000000200000
+patword 0x0043 0x0000000000200000
+patword 0x0044 0x0000000001200000
+patword 0x0045 0x0000000000200000
+patword 0x0046 0x0000000000200000
+patword 0x0047 0x0000000000200000
+patword 0x0048 0x0000000000200000
+patword 0x0049 0x0000000000200000
+patword 0x004a 0x0000000000200000
+patword 0x004b 0x0000000000200000
+patword 0x004c 0x0000000000200000
+patword 0x004d 0x0000000001200000
+patword 0x004e 0x0000000000200000
+patword 0x004f 0x0000000000200000
+patword 0x0050 0x0000000000200000
+patword 0x0051 0x0000000000200000
+patword 0x0052 0x0000000000200000
+patword 0x0053 0x0000000000200000
+patword 0x0054 0x0000000000200000
+patword 0x0055 0x0000000000200000
+patword 0x0056 0x0000000001200000
+patword 0x0057 0x0000000000200000
+patword 0x0058 0x0000000000200000
+patword 0x0059 0x0000000000200000
+patword 0x005a 0x0000000000280000
+patword 0x005b 0x0000000000280000
+patword 0x005c 0x0000000000280000
+patword 0x005d 0x0000000000280000
+patword 0x005e 0x0000000000280000
+patword 0x005f 0x0000000001280000
+patword 0x0060 0x0000000000280000
+patword 0x0061 0x0000000000200000
+patword 0x0062 0x0000000000200000
+patword 0x0063 0x0000000000200000
+patword 0x0064 0x0000000000200000
+patword 0x0065 0x0000000000200000
+patword 0x0066 0x0000000000200000
+patword 0x0067 0x0000000000200000
+patword 0x0068 0x0000000001200000
+patword 0x0069 0x0000000000200000
+patword 0x006a 0x0000000000200000
+patword 0x006b 0x0000000000200000
+patword 0x006c 0x0000000000200000
+patword 0x006d 0x0000000000200000
+patword 0x006e 0x0000000000200000
+patword 0x006f 0x0000000000200000
+patword 0x0070 0x0000000000200000
+patword 0x0071 0x0000000001200000
+patword 0x0072 0x0000000000200000
+patword 0x0073 0x0000000000200000
+patword 0x0074 0x0000000000200000
+patword 0x0075 0x0000000000200000
+patword 0x0076 0x0000000000200000
+patword 0x0077 0x0000000000200000
+patword 0x0078 0x0000000000200000
+patword 0x0079 0x0000000000200000
+patword 0x007a 0x0000000001200000
+patword 0x007b 0x0000000000200000
+patword 0x007c 0x0000000000200000
+patword 0x007d 0x0000000000200000
+patword 0x007e 0x0000000000280000
+patword 0x007f 0x0000000000280000
+patword 0x0080 0x0000000000280000
+patword 0x0081 0x0000000000280000
+patword 0x0082 0x0000000000280000
+patword 0x0083 0x0000000001280000
+patword 0x0084 0x0000000000280000
+patword 0x0085 0x0000000000200000
+patword 0x0086 0x0000000000200000
+patword 0x0087 0x0000000000200000
+patword 0x0088 0x0000000000200000
+patword 0x0089 0x0000000000200000
+patword 0x008a 0x0000000000200000
+patword 0x008b 0x0000000000200000
+patword 0x008c 0x0000000001200000
+patword 0x008d 0x0000000000200000
+patword 0x008e 0x0000000000200000
+patword 0x008f 0x0000000000200000
+patword 0x0090 0x0000000000200000
+patword 0x0091 0x0000000000200000
+patword 0x0092 0x0000000000200000
+patword 0x0093 0x0000000000200000
+patword 0x0094 0x0000000000200000
+patword 0x0095 0x0000000001200000
+patword 0x0096 0x0000000000200000
+patword 0x0097 0x0000000000200000
+patword 0x0098 0x0000000000200000
+patword 0x0099 0x0000000000200000
+patword 0x009a 0x0000000000200000
+patword 0x009b 0x0000000000200000
+patword 0x009c 0x0000000000200000
+patword 0x009d 0x0000000000200000
+patword 0x009e 0x0000000001200000
+patword 0x009f 0x0000000000200000
+patword 0x00a0 0x0000000000200000
+patword 0x00a1 0x0000000000200000
+patword 0x00a2 0x0000000000200000
+patword 0x00a3 0x0000000000200000
+patword 0x00a4 0x0000000000200000
+patword 0x00a5 0x0000000000200000
+patword 0x00a6 0x0000000000200000
+patword 0x00a7 0x0000000001200000
+patword 0x00a8 0x0000000000200000
+patword 0x00a9 0x0000000000200000
+patword 0x00aa 0x0000000000200000
+patword 0x00ab 0x0000000000200000
+patword 0x00ac 0x0000000000200000
+patword 0x00ad 0x0000000000200000
+patword 0x00ae 0x0000000000200000
+patword 0x00af 0x0000000000200000
+patword 0x00b0 0x0000000001200000
+patword 0x00b1 0x0000000000200000
+patword 0x00b2 0x0000000000200000
+patword 0x00b3 0x0000000000200000
+patword 0x00b4 0x0000000000200000
+patword 0x00b5 0x0000000000200000
+patword 0x00b6 0x0000000000200000
+patword 0x00b7 0x0000000000200000
+patword 0x00b8 0x0000000000200000
+patword 0x00b9 0x0000000001200000
+patword 0x00ba 0x0000000000200000
+patword 0x00bb 0x0000000000200000
+patword 0x00bc 0x0000000000200000
+patword 0x00bd 0x0000000000200000
+patword 0x00be 0x0000000000200000
+patword 0x00bf 0x0000000000200000
+patword 0x00c0 0x0000000000200000
+patword 0x00c1 0x0000000000200000
+patword 0x00c2 0x0000000001200000
+patword 0x00c3 0x0000000000200000
+patword 0x00c4 0x0000000000200000
+patword 0x00c5 0x0000000000200000
+patword 0x00c6 0x0000000000300000
+patword 0x00c7 0x0000000000300000
+patword 0x00c8 0x0000000000300000
+patword 0x00c9 0x0000000000300000
+patword 0x00ca 0x0000000000300000
+patword 0x00cb 0x0000000000200000
+patword 0x00cc 0x0000000000200000
+patword 0x00cd 0x0000000000200000
+patword 0x00ce 0x0000000000200000
+patword 0x00cf 0x0000000000200000
+patword 0x00d0 0x0000000000200000
+patword 0x00d1 0x0000000000200000
+patword 0x00d2 0x0000000000000000
+patword 0x00d3 0x0000000000000000
+patword 0x00d4 0x0000000000000000
+patword 0x00d5 0x0000000000000000
+patword 0x00d6 0x0000000000000000
+patword 0x00d7 0x0000000000000000
+patword 0x00d8 0x0000000000000000
+patword 0x00d9 0x0000000000000000
+patword 0x00da 0x0000000000c00000
+patword 0x00db 0x0000000000c00000
+patword 0x00dc 0x0000000000c00000
+patword 0x00dd 0x0000000000c00000
+patword 0x00de 0x0000000000c00000
+patword 0x00df 0x0000000000c00000
+patword 0x00e0 0x0000000000c00000
+patword 0x00e1 0x0000000000c00000
+patword 0x00e2 0x0000000000c00000
+patword 0x00e3 0x0000000000c00000
+patword 0x00e4 0x0000000000000000
+patword 0x00e5 0x0000000000000000
+patword 0x00e6 0x0000000000000000
+patword 0x00e7 0x0000000000000000
+patword 0x00e8 0x0000000000000000
+patword 0x00e9 0x0000000000000000
+patword 0x00ea 0x0000000000000000
+patword 0x00eb 0x0000000000000000
+patword 0x00ec 0x0000000000000000
+patword 0x00ed 0x0000000000000000
+patword 0x00ee 0x0000000000000000
+patword 0x00ef 0x0000000000000000
+patword 0x00f0 0x0000000000000000
+patword 0x00f1 0x0000000000000000
+patword 0x00f2 0x0000000000000000
+patlimits 0x0000 0x00f2
+patloop0 0x0400 0x0400
+patnloop0 0
+patloop1 0x0400 0x0400
+patnloop1 0
+patloop2 0x0400 0x0400
+patnloop2 0
+patwait0 0x0400
+patwaittime0 0
+patwait1 0x0400
+patwaittime1 0
+patwait2 0x0400
+patwaittime2 0
--- a/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
+++ b/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
--- a/slsDetectorServers/mythen3DetectorServer/mythen3.c
+++ b/slsDetectorServers/mythen3DetectorServer/mythen3.c
@ -0,0 +1,374 @@
+
+#include "clogger.h"
+#include "common.h"
+#include "mythen3.h"
+#include "sls/ansi.h"
+#include "sls/sls_detector_defs.h"
+#include "slsDetectorServer_defs.h"
+
+#include <string.h>
+
+/*
+// Common C/C++ structure to handle pattern data
+typedef struct __attribute__((packed)) {
+    uint64_t word[MAX_PATTERN_LENGTH];
+    uint64_t ioctrl;
+    uint32_t limits[2];
+    // loop0 start, loop0 stop .. loop2 start, loop2 stop
+    uint32_t loop[6];
+    uint32_t nloop[3];
+    uint32_t wait[3];
+    uint64_t waittime[3];
+} patternParameters;
+*/
+
+int chipStatusRegister=0;
+
+int setBit(int ibit, int patword) { return patword |= (1 << ibit); }
+
+int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); }
+
+extern enum TLogLevel trimmingPrint ;
+
+
+int getChipStatusRegister(){
+  return chipStatusRegister;
+}
+
+int gainCapsToCsr(int caps){
+  //Translates bit representation
+  int csr = 0;
+  if (!(caps & M3_C10pre))
+    csr |= 1 << _CSR_C10pre;
+  if (caps & M3_C15sh)
+    csr |= 1 << CSR_C15sh;
+  if (caps & M3_C30sh)
+    csr |= 1 << CSR_C30sh;
+  if (caps & M3_C50sh)
+    csr |= 1 << CSR_C50sh;
+  if (caps & M3_C225ACsh)
+    csr |= 1 << CSR_C225ACsh;
+  if (!(caps & M3_C15pre))
+    csr |= 1 << _CSR_C15pre;
+
+  return csr;
+}
+
+int csrToGainCaps(int csr){
+  //Translates bit representation
+  int caps = 0;
+  if (!(csr & (1 << _CSR_C10pre)))
+    caps |= M3_C10pre;
+  if (csr & (1 << CSR_C15sh))
+    caps |= M3_C15sh;
+  if (csr & (1 << CSR_C30sh))
+    caps |= M3_C30sh;
+  if (csr & (1 << CSR_C50sh))
+    caps |= M3_C50sh;
+  if (csr & (1 << CSR_C225ACsh))
+    caps |= M3_C225ACsh;
+  if (!(csr & (1 << _CSR_C15pre)))
+    caps |= M3_C15pre;
+
+  return caps;
+}
+
+patternParameters *setChipStatusRegisterPattern(int csr) {
+  int iaddr=0;
+  int  nbits=18;
+  int error=0;
+  //int start=0, stop=MAX_PATTERN_LENGTH, loop=0;
+  int patword=0;
+  
+  patternParameters *pat = malloc(sizeof(patternParameters));
+  memset(pat, 0, sizeof(patternParameters));
+  
+  patword=setBit(SIGNAL_STATLOAD,patword);
+  for (int i=0; i<2; i++)
+    pat->word[iaddr++]=patword;
+  patword=setBit(SIGNAL_resStorage,patword);
+  patword=setBit(SIGNAL_resCounter,patword);
+  for (int i=0; i<8; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_resStorage,patword);
+  patword=clearBit(SIGNAL_resCounter,patword);
+  for (int i=0; i<8; i++)
+    pat->word[iaddr++]=patword;
+  //#This version of the serializer pushes in the MSB first (compatible with the CSR bit numbering)
+  for (int ib=nbits-1; ib>=0; ib--) {
+    if (csr&(1<<ib))
+      patword=setBit(SIGNAL_serialIN,patword);
+    else
+      patword=clearBit(SIGNAL_serialIN,patword);
+    for (int i=0; i<4; i++)
+      pat->word[iaddr++]=patword;
+    patword=setBit(SIGNAL_CHSclk,patword);
+    pat->word[iaddr++]=patword;
+    patword=clearBit(SIGNAL_CHSclk,patword);
+    pat->word[iaddr++]=patword;
+  }
+
+  patword=clearBit(SIGNAL_serialIN,patword);
+  for (int i=0; i<2; i++)
+    pat->word[iaddr++]=patword;
+  patword=setBit(SIGNAL_STO,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_STO,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_STATLOAD,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  // set pattern wait address
+  for (int i = 0; i <= 2; i++)
+    pat->wait[i]=MAX_PATTERN_LENGTH - 1;
+  // pattern loop
+  for (int i = 0; i <= 2; i++) {
+    //int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
+    pat->loop[i * 2 + 0]=MAX_PATTERN_LENGTH - 1;
+    pat->loop[i * 2 + 1]=MAX_PATTERN_LENGTH - 1;
+    pat->nloop[i]=0;
+  }
+  
+  // pattern limits
+  {
+    pat->limits[0]=0;
+    pat->limits[1]=iaddr;
+  }
+  
+  if (error != 0) {
+    free(pat);
+    return NULL;
+  }
+  chipStatusRegister=csr;
+  return pat;
+
+}
+
+patternParameters *setInterpolation(int mask) {
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_interp);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_interp);
+
+  return setChipStatusRegisterPattern(csr);
+}
+
+
+
+patternParameters *setPumpProbe(int mask) {
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_pumprobe);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_pumprobe);
+
+  return setChipStatusRegisterPattern(csr);
+
+}
+patternParameters *setDigitalPulsing(int mask) {
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_dpulse);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_dpulse);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+patternParameters *setAnalogPulsing(int mask){
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_apulse);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_apulse);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+patternParameters *setNegativePolarity(int mask){
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_invpol);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_invpol);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+
+patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits) {
+
+  patternParameters *pat = malloc(sizeof(patternParameters));
+  memset(pat, 0, sizeof(patternParameters));
+  
+
+    // validate
+  for (int ichan = ichip * NCHAN_1_COUNTER * NCOUNTERS; ichan < ichip * NCHAN_1_COUNTER * NCOUNTERS+NCHAN_1_COUNTER*NCOUNTERS; ichan++) {
+    if (trimbits[ichan]<0)  {
+      LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - setting it to 0\n",
+		     trimbits[ichan], ichan));
+      trimbits[ichan]=0;
+    }
+    if (trimbits[ichan] > 63) {
+      LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - settings it to 63\n",
+		     trimbits[ichan], ichan));
+      trimbits[ichan]=63;
+    }
+  }
+  LOG(logINFO, ("Trimbits validated\n"));
+  trimmingPrint = logDEBUG5;
+
+    
+  // trimming
+  int error = 0;
+  uint64_t patword = 0;
+  int iaddr = 0;
+  
+  LOG(logDEBUG1, (" Chip %d\n", ichip));
+  iaddr = 0;
+  patword = 0;
+  pat->word[iaddr++]=patword;
+  
+  // chip select
+  patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
+  pat->word[iaddr++]=patword;
+  
+  // reset trimbits
+  patword = setBit(SIGNAL_resStorage, patword);
+  patword = setBit(SIGNAL_resCounter, patword);
+  pat->word[iaddr++]=patword;
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_resStorage, patword);
+  patword = clearBit(SIGNAL_resCounter, patword);
+  pat->word[iaddr++]=patword;
+  pat->word[iaddr++]=patword;
+  
+  // select first channel
+  patword = setBit(SIGNAL_CHSserialIN, patword);
+  pat->word[iaddr++]=patword;
+  // 1 clk pulse
+  patword = setBit(SIGNAL_CHSclk, patword);
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_CHSclk, patword);
+  // clear 1st channel
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_CHSserialIN, patword);
+  // 2 clk pulses
+  for (int i = 0; i < 2; i++) {
+    patword = setBit(SIGNAL_CHSclk, patword);
+    pat->word[iaddr++]=patword;
+    patword = clearBit(SIGNAL_CHSclk, patword);
+    pat->word[iaddr++]=patword;
+  }
+  
+  // for each channel (all chips)
+  for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
+    LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
+    int val = trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+		       NCOUNTERS * ich] +
+      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+	       NCOUNTERS * ich + 1] *
+      64 +
+      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+	       NCOUNTERS * ich + 2] *
+      64 * 64;
+    
+    // push 6 0 bits
+    for (int i = 0; i < 3; i++) {
+      patword = clearBit(SIGNAL_serialIN, patword);
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    
+    for (int i = 0; i < 3; i++) {
+      if (mask[i])
+	patword = setBit(SIGNAL_serialIN, patword);
+      else
+	patword = clearBit(SIGNAL_serialIN, patword);
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    
+    // deserialize
+    for (int i = 0; i < 18; i++) {
+      if (val & (1 << i)) {
+	patword = setBit(SIGNAL_serialIN, patword);
+      } else {
+	patword = clearBit(SIGNAL_serialIN, patword);
+      }
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    pat->word[iaddr++]=patword;
+    pat->word[iaddr++]=patword;
+    
+    // move to next channel
+    for (int i = 0; i < 3; i++) {
+      patword = setBit(SIGNAL_CHSclk, patword);
+      pat->word[iaddr++]=patword;
+      patword = clearBit(SIGNAL_CHSclk, patword);
+      pat->word[iaddr++]=patword;
+    }
+  }
+  // chip unselect
+  patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
+  pat->word[iaddr++]=patword;
+  
+  // last iaddr check
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  // set pattern wait address
+  for (int i = 0; i <= 2; i++)
+    pat->wait[i]=MAX_PATTERN_LENGTH - 1;
+  // pattern loop
+  for (int i = 0; i <= 2; i++) {
+    //int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
+    pat->loop[i * 2 + 0]=MAX_PATTERN_LENGTH - 1;
+    pat->loop[i * 2 + 1]=MAX_PATTERN_LENGTH - 1;
+    pat->nloop[i]=0;
+  }
+  
+  // pattern limits
+  {
+    pat->limits[0]=0;
+    pat->limits[1]=iaddr;
+  }
+  
+  trimmingPrint = logINFO;
+  if (error == 0) {
+    
+    LOG(logINFO, ("All trimbits have been loaded\n"));
+  } else {
+    free(pat);
+    return NULL;
+  }
+  return pat;
+}
--- a/slsDetectorServers/mythen3DetectorServer/mythen3.h
+++ b/slsDetectorServers/mythen3DetectorServer/mythen3.h
@ -0,0 +1,68 @@
+#ifndef MYTHEN3_H
+#define MYTHEN3_H
+
+#include "Pattern.h"
+
+/** Signal Definitions */
+#define SIGNAL_TBLoad_1    (0)
+#define SIGNAL_TBLoad_2    (1)
+#define SIGNAL_TBLoad_3    (2)
+#define SIGNAL_TBLoad_4    (3)
+#define SIGNAL_TBLoad_5    (4)
+#define SIGNAL_TBLoad_6    (5)
+#define SIGNAL_TBLoad_7    (6)
+#define SIGNAL_TBLoad_8    (7)
+#define SIGNAL_TBLoad_9    (8)
+#define SIGNAL_TBLoad_10   (9)
+#define SIGNAL_AnaMode     (10)
+#define SIGNAL_CHSserialIN (11)
+#define SIGNAL_READOUT     (12)
+#define SIGNAL_pulse       (13)
+#define SIGNAL_EN1         (14)
+#define SIGNAL_EN2         (15)
+#define SIGNAL_EN3         (16)
+#define SIGNAL_clk         (17)
+#define SIGNAL_SRmode      (18)
+#define SIGNAL_serialIN    (19)
+#define SIGNAL_STO         (20)
+#define SIGNAL_STATLOAD    (21)
+#define SIGNAL_resStorage  (22)
+#define SIGNAL_resCounter  (23)
+#define SIGNAL_CHSclk      (24)
+#define SIGNAL_exposing    (25)
+
+
+//CHIP STARTUS REGISTER BITS
+#define CSR_spypads  0
+#define CSR_invpol  4
+#define CSR_dpulse  5
+#define CSR_interp  6
+#define _CSR_C10pre  7 //#default, negative polarity
+#define CSR_pumprobe  8
+#define CSR_apulse  9
+#define CSR_C15sh  10 
+#define CSR_C30sh  11 //#default
+#define CSR_C50sh  12
+#define CSR_C225ACsh  13 // Connects 225fF SHAPER AC cap (1: 225 to shaper, 225 to GND. 0: 450 to shaper) 
+#define _CSR_C15pre  14 // negative polarity
+
+#define CSR_default  (1<<_CSR_C10pre )|(1<< CSR_C30sh)
+
+#define GAIN_MASK ((1 << _CSR_C10pre) | ( 1 << CSR_C15sh) | (1 << CSR_C30sh) | (1 << CSR_C50sh) | (1 << CSR_C225ACsh) | ( 1 << _CSR_C15pre))
+
+
+int setBit(int ibit, int patword);
+int clearBit(int ibit, int patword);
+int getChipStatusRegister();
+int gainCapsToCsr(int caps);
+int csrToGainCaps(int csr);
+
+patternParameters *setChipStatusRegisterPattern(int csr);
+patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits);
+patternParameters *setInterpolation(int mask);
+patternParameters *setPumpProbe(int mask);
+patternParameters *setDigitalPulsing(int mask);
+patternParameters *setAnalogPulsing(int mask);
+patternParameters *setNegativePolarity(int mask);
+
+#endif
--- a/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
@ -5,6 +5,8 @@
 #include "RegisterDefs.h"
 #include "clogger.h"
 #include "common.h"
+#include "mythen3.h"
+#include "loadPattern.h"
 #include "sharedMemory.h"
 #include "sls/versionAPI.h"
 #ifdef VIRTUAL
@ -19,8 +21,6 @@
 #include <time.h>
 #endif

-/// NOT the right place to put it!
-int setChipStatusRegister(int csr);

 // Global variable from slsDetectorServer_funcs
 extern int debugflag;
@ -47,11 +47,12 @@ enum detectorSettings thisSettings;
 sls_detector_module *detectorModules = NULL;
 int *detectorChans = NULL;
 int *detectorDacs = NULL;
+int *channelMask=NULL;

-enum TLogLevel trimmingPrint = logINFO;
 int32_t clkPhase[NUM_CLOCKS] = {};
 uint32_t clkDivider[NUM_CLOCKS] = {};

+enum TLogLevel trimmingPrint = logINFO;
 int highvoltage = 0;
 int detPos[2] = {};
 int64_t exptimeReg[NCOUNTERS] = {0, 0, 0};
@ -374,7 +375,11 @@ void allocateDetectorStructureMemory() {
    // Allocation of memory
    detectorModules = malloc(sizeof(sls_detector_module));
    detectorChans = malloc(NCHIP * NCHAN * sizeof(int));
+    channelMask = malloc(NCHIP * NCHAN * sizeof(char));
+    memset(channelMask, 0, NCHIP * NCHAN * sizeof(char));
    detectorDacs = malloc(NDAC * sizeof(int));
+
+    
    LOG(logDEBUG1,
        ("modules from 0x%x to 0x%x\n", detectorModules, detectorModules));
    LOG(logDEBUG1, ("chans from 0x%x to 0x%x\n", detectorChans, detectorChans));
@ -512,11 +517,11 @@ void setupDetector() {
    }

    powerChip(1);
-    if (initError != FAIL) {
-      initError = setChipStatusRegister(CSR_default);
-      //loadDefaultPattern(DEFAULT_PATTERN_FILE, initErrorMessage);
-      //startStateMachine(); //this was missing in previous code! runs the default pattern
+
+    if (!initError) {
+      setChipStatusRegister(CSR_default);
    }
+
    setAllTrimbits(DEFAULT_TRIMBIT_VALUE);
 }

@ -1052,72 +1057,44 @@ int64_t getMeasurementTime() {

 /* parameters - module, speed, readout */

-int setModule(sls_detector_module myMod, char *mess) {
-
-    LOG(logINFO, ("Setting module\n"));
-
-    // settings
-    if (myMod.reg >= 0) {
-        setSettings((enum detectorSettings)myMod.reg);
-        if (getSettings() != (enum detectorSettings)myMod.reg) {
-            sprintf(
-                mess,
-                "Could not set module. Could not set settings to %d, read %d\n",
-                myMod.reg, (int)getSettings());
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-        detectorModules->reg = myMod.reg;
-    }
-    // custom trimbit file
-    else {
-        // changed for setsettings (direct),
-        // custom trimbit file (setmodule with myMod.reg as -1),
-        // change of dac (direct)
-        for (int i = 0; i < NCOUNTERS; ++i) {
-            setThresholdEnergy(i, -1);
-        }
-    }
-
-    // dacs
+int setDACS(int* dacs){
    for (int i = 0; i < NDAC; ++i) {
-        // ignore dacs with -1
-        if (myMod.dacs[i] != -1) {
-            setDAC((enum DACINDEX)i, myMod.dacs[i], 0);
-            if (myMod.dacs[i] != detectorDacs[i]) {
+        if (dacs[i] != -1) {
+            setDAC((enum DACINDEX)i, dacs[i], 0);
+            if (dacs[i] != detectorDacs[i]) {
                // dont complain if that counter was disabled
                if ((i == M_VTH1 || i == M_VTH2 || i == M_VTH3) &&
                    (detectorDacs[i] == DEFAULT_COUNTER_DISABLED_VTH_VAL)) {
                    continue;
                }
-                sprintf(mess,
-                        "Could not set module. Could not set dac %d, wrote %d, "
-                        "read %d\n",
-                        i, myMod.dacs[i], detectorDacs[i]);
-                LOG(logERROR, (mess));
                return FAIL;
            }
        }
    }
+    return OK;
+}

-    // if settings given and cannot be validated (after setting dacs), return
-    // error
-    if (myMod.reg >= 0) {
-        if (getSettings() != (enum detectorSettings)myMod.reg) {
-            sprintf(
-                mess,
-                "Could not set module. The dacs in file do not correspond to "
-                "settings %d\n",
-                myMod.reg);
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
+
+int setModule(sls_detector_module myMod, char *mess) {
+    LOG(logINFO, ("Setting module\n"));
+
+    if (setChipStatusRegister(myMod.reg)){
+        sprintf(mess, "Could not CSR from module\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+
+    if (setDACS(myMod.dacs)){
+        sprintf(mess, "Could not set dacs\n");
+        LOG(logERROR, (mess));
+        return FAIL;
    }

-    // threshold
    for (int i = 0; i < NCOUNTERS; ++i) {
        if (myMod.eV[i] >= 0) {
            setThresholdEnergy(i, myMod.eV[i]);
+        }else{
+            setThresholdEnergy(i, -1);
        }
    }

@ -1136,155 +1113,31 @@ int setModule(sls_detector_module myMod, char *mess) {
    return OK;
 }

-int setBit(int ibit, int patword) { return patword |= (1 << ibit); }
-
-int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); }
-
 int setTrimbits(int *trimbits) {
-    LOG(logINFOBLUE, ("Setting trimbits\n"));
-
-    // validate
-    for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) {
-        if (trimbits[ichan] < 0 || trimbits[ichan] > 63) {
-            LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid\n",
-                           trimbits[ichan], ichan));
-            return FAIL;
-        }
-    }
-    LOG(logINFO, ("Trimbits validated\n"));
-    trimmingPrint = logDEBUG5;
-
    // remember previous run clock
    uint32_t prevRunClk = clkDivider[SYSTEM_C0];
-
+    patternParameters *pat = NULL;
+    int error = 0;
    // set to trimming clock
    if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
        LOG(logERROR,
            ("Could not start trimming. Could not set to trimming clock\n"));
        return FAIL;
    }
-
-    // trimming
-    int error = 0;
-    uint64_t patword = 0;
-    int iaddr = 0;
+    /////////////////////////////////////////////////////////////////
    for (int ichip = 0; ichip < NCHIP; ichip++) {
-        if (error != 0) {
-            break;
-        }
-        LOG(logDEBUG1, (" Chip %d\n", ichip));
-        iaddr = 0;
-        patword = 0;
-        writePatternWord(iaddr++, patword);

-        // chip select
-        patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
-        writePatternWord(iaddr++, patword);
-
-        // reset trimbits
-        patword = setBit(SIGNAL_resStorage, patword);
-        patword = setBit(SIGNAL_resCounter, patword);
-        writePatternWord(iaddr++, patword);
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_resStorage, patword);
-        patword = clearBit(SIGNAL_resCounter, patword);
-        writePatternWord(iaddr++, patword);
-        writePatternWord(iaddr++, patword);
-
-        // select first channel
-        patword = setBit(SIGNAL_CHSserialIN, patword);
-        writePatternWord(iaddr++, patword);
-        // 1 clk pulse
-        patword = setBit(SIGNAL_CHSclk, patword);
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_CHSclk, patword);
-        // clear 1st channel
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_CHSserialIN, patword);
-        // 2 clk pulses
-        for (int i = 0; i < 2; i++) {
-            patword = setBit(SIGNAL_CHSclk, patword);
-            writePatternWord(iaddr++, patword);
-            patword = clearBit(SIGNAL_CHSclk, patword);
-            writePatternWord(iaddr++, patword);
-        }
-
-        // for each channel (all chips)
-        for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
-            LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
-            int val = trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich] +
-                      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich + 1] *
-                          64 +
-                      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich + 2] *
-                          64 * 64;
-
-            // push 6 0 bits
-            for (int i = 0; i < 6; i++) {
-                patword = clearBit(SIGNAL_serialIN, patword);
-                patword = clearBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-                patword = setBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-
-            // deserialize
-            for (int i = 0; i < 18; i++) {
-                if (val & (1 << i)) {
-                    patword = setBit(SIGNAL_serialIN, patword);
-                } else {
-                    patword = clearBit(SIGNAL_serialIN, patword);
-                }
-                patword = clearBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-
-                patword = setBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-            writePatternWord(iaddr++, patword);
-            writePatternWord(iaddr++, patword);
-
-            // move to next channel
-            for (int i = 0; i < 3; i++) {
-                patword = setBit(SIGNAL_CHSclk, patword);
-                writePatternWord(iaddr++, patword);
-                patword = clearBit(SIGNAL_CHSclk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-        }
-        // chip unselect
-        patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
-        writePatternWord(iaddr++, patword);
-
-        // last iaddr check
-        if (iaddr >= MAX_PATTERN_LENGTH) {
-            LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
-                           iaddr, MAX_PATTERN_LENGTH));
+        pat = setChannelRegisterChip(ichip, channelMask,
+                                     trimbits); // change here!!!
+        if (pat) {
+            error |= loadPattern(pat);
+            if (error == 0)
+                startPattern();
+            free(pat);
+        } else
            error = 1;
-            break;
-        }
-
-        // set pattern wait address
-        for (int i = 0; i <= 2; i++)
-            setPatternWaitAddress(i, MAX_PATTERN_LENGTH - 1);
-
-        // pattern loop
-        for (int i = 0; i <= 2; i++) {
-            int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
-            setPatternLoop(i, &stop, &stop, &nloop);
-        }
-
-        // pattern limits
-        {
-            int start = 0, nloop = 0;
-            setPatternLoop(-1, &start, &iaddr, &nloop);
-        }
-        // send pattern to the chips
-        startPattern();
    }
-
+    /////////////////////////////////////////////////////////////////
    if (error == 0) {
        // copy trimbits locally
        for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) {
@ -1292,7 +1145,6 @@ int setTrimbits(int *trimbits) {
        }
        LOG(logINFO, ("All trimbits have been loaded\n"));
    }
-
    trimmingPrint = logINFO;
    // set back to previous clock
    if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
@ -1303,7 +1155,6 @@ int setTrimbits(int *trimbits) {
    if (error != 0) {
        return FAIL;
    }
-
    return OK;
 }

@ -2780,76 +2631,51 @@ int getNumberOfDACs() { return NDAC; }
 int getNumberOfChannelsPerChip() { return NCHAN; }

 int setChipStatusRegister(int csr) {
-  int iaddr=0;
-  int  nbits=18;
-  int error=0;
-  //int start=0, stop=MAX_PATTERN_LENGTH, loop=0;
-  int patword=0;
-  patword=setBit(SIGNAL_STATLOAD,patword);
-  for (int i=0; i<2; i++)
-    writePatternWord(iaddr++, patword);
-  patword=setBit(SIGNAL_resStorage,patword);
-  patword=setBit(SIGNAL_resCounter,patword);
-  for (int i=0; i<8; i++)
-    writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_resStorage,patword);
-  patword=clearBit(SIGNAL_resCounter,patword);
-  for (int i=0; i<8; i++)
-    writePatternWord(iaddr++, patword);
-  //#This version of the serializer pushes in the MSB first (compatible with the CSR bit numbering)
-  for (int ib=nbits-1; ib>=0; ib--) {
-    if (csr&(1<<ib))
-      patword=setBit(SIGNAL_serialIN,patword);
-    else
-      patword=clearBit(SIGNAL_serialIN,patword);
-    for (int i=0; i<4; i++)
-      writePatternWord(iaddr++, patword);
-    patword=setBit(SIGNAL_CHSclk,patword);
-    writePatternWord(iaddr++, patword);
-    patword=clearBit(SIGNAL_CHSclk,patword);
-    writePatternWord(iaddr++, patword);
-  }
+    uint32_t prevRunClk = clkDivider[SYSTEM_C0];
+    patternParameters *pat = NULL;

-  patword=clearBit(SIGNAL_serialIN,patword);
-  for (int i=0; i<2; i++)
-      writePatternWord(iaddr++, patword);
-  patword=setBit(SIGNAL_STO,patword);
-  for (int i=0; i<5; i++)
-      writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_STO,patword);
-  for (int i=0; i<5; i++)
-    writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_STATLOAD,patword);
-  for (int i=0; i<5; i++)
-    writePatternWord(iaddr++, patword);
+    int error = 0;
+    if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
+        LOG(logERROR,
+            ("Could not set to trimming clock in order to change CSR\n"));
+        return FAIL;
+    }
+    pat = setChipStatusRegisterPattern(csr);

-  if (iaddr >= MAX_PATTERN_LENGTH) {
-    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
-		   iaddr, MAX_PATTERN_LENGTH));
-    error = 1;
-  }
-  // set pattern wait address
-  for (int i = 0; i <= 2; i++)
-    setPatternWaitAddress(i, MAX_PATTERN_LENGTH - 1);
-  
-  // pattern loop
-  for (int i = 0; i <= 2; i++) {
-    int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
-    setPatternLoop(i, &stop, &stop, &nloop);
-  }
-  
-  // pattern limits
-  {
-    int start = 0, nloop = 0;
-    setPatternLoop(-1, &start, &iaddr, &nloop);
-  }
-  // send pattern to the chips
-  startPattern();
-  
-  if (error != 0) {
-    return FAIL;
-  }
-  
-  return OK;
+    if (pat) {
+        error |= loadPattern(pat);
+        if (!error)
+            startPattern();
+        free(pat);
+    } else {
+        error = 1;
+    }

+    if (!error) {
+        LOG(logINFO, ("CSR is now: 0x%x\n", csr));
+    }
+
+    if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
+        LOG(logERROR,
+            ("Could not set to previous run clock after changing CSR\n"));
+        return FAIL;
+    }
+    return OK;
+}
+
+int setGainCaps(int caps){
+    // Update only gain caps, leave the rest of the CSR unchanged
+    int csr = getChipStatusRegister();
+    csr &= ~GAIN_MASK;
+
+    caps = gainCapsToCsr(caps);
+    // caps &= GAIN_MASK;
+    csr |= caps;
+    return setChipStatusRegister(csr);
+}
+
+int getGainCaps(){
+    int csr = getChipStatusRegister();
+    int caps = csrToGainCaps(csr);
+    return caps; 
 }
--- a/slsDetectorServers/mythen3DetectorServer/slsDetectorServer_defs.h
+++ b/slsDetectorServers/mythen3DetectorServer/slsDetectorServer_defs.h
@ -1,7 +1,7 @@
 #pragma once
 #include "sls/sls_detector_defs.h"

-#define REQRD_FRMWRE_VRSN (0x200925)
+#define REQRD_FRMWRE_VRSN (0x210201)
 #define KERNEL_DATE_VRSN  "Wed May 20 13:58:38 CEST 2020"
 #define ID_FILE           "detid_mythen3.txt"

@ -47,7 +47,7 @@
 #define DEFAULT_HIGHGAIN_VRPREAMP (1300)
 #define DEFAULT_STANDARD_VRSHAPER (1280)
 #define DEFAULT_FAST_VRSHAPER     (1500)
-#define DEFAULT_HIGHGAIN_VRSHAPER (900)
+#define DEFAULT_HIGHGAIN_VRSHAPER (1100)

 #define DEFAULT_READOUT_C0 (10) //(100000000) // rdo_clk, 100 MHz
 #define DEFAULT_READOUT_C1 (10) //(100000000) // smp sample clk (x2), 100 MHz
@ -158,47 +158,3 @@ typedef struct udp_header_struct {
 #define UDP_IP_HEADER_LENGTH_BYTES (28)
 #define PACKETS_PER_FRAME_10G      (2)
 #define PACKETS_PER_FRAME_1G       (20)
-
-/** Signal Definitions */
-#define SIGNAL_TBLoad_1    (0)
-#define SIGNAL_TBLoad_2    (1)
-#define SIGNAL_TBLoad_3    (2)
-#define SIGNAL_TBLoad_4    (3)
-#define SIGNAL_TBLoad_5    (4)
-#define SIGNAL_TBLoad_6    (5)
-#define SIGNAL_TBLoad_7    (6)
-#define SIGNAL_TBLoad_8    (7)
-#define SIGNAL_TBLoad_9    (8)
-#define SIGNAL_TBLoad_10   (9)
-#define SIGNAL_AnaMode     (10)
-#define SIGNAL_CHSserialIN (11)
-#define SIGNAL_READOUT     (12)
-#define SIGNAL_pulse       (13)
-#define SIGNAL_EN1         (14)
-#define SIGNAL_EN2         (15)
-#define SIGNAL_EN3         (16)
-#define SIGNAL_clk         (17)
-#define SIGNAL_SRmode      (18)
-#define SIGNAL_serialIN    (19)
-#define SIGNAL_STO         (20)
-#define SIGNAL_STATLOAD    (21)
-#define SIGNAL_resStorage  (22)
-#define SIGNAL_resCounter  (23)
-#define SIGNAL_CHSclk      (24)
-#define SIGNAL_exposing    (25)
-
-//CHIP STARTUS REGISTER BITS
-#define CSR_spypads  0
-#define CSR_invpol  4
-#define CSR_dpulse  5
-#define CSR_interp  6
-#define CSR_C10pre  7 //#default
-#define CSR_pumprobe  8
-#define CSR_apulse  9
-#define CSR_C15sh  10 
-#define CSR_C30sh  11 //#default
-#define CSR_C50sh  12
-#define CSR_C225ACsh  13 // Connects 225fF SHAPER AC cap (1: 225 to shaper, 225 to GND. 0: 450 to shaper) 
-#define CSR_C15pre  14 
-
-#define CSR_default  (1<<CSR_C10pre )|(1<< CSR_C30sh)
--- a/slsDetectorServers/slsDetectorServer/include/loadPattern.h
+++ b/slsDetectorServers/slsDetectorServer/include/loadPattern.h
@ -0,0 +1,6 @@
+#ifndef LOADPATTERN_H
+#define LOADPATTERN_H
+#include "Pattern.h"
+
+int loadPattern(patternParameters *pat);
+#endif
--- a/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
+++ b/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
@ -25,6 +25,10 @@
 #include "blackfin.h"
 #endif

+#if defined(MYTHEN3D) 
+#include "mythen3.h"
+#endif
+
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@ -353,6 +357,10 @@ enum timingMode getTiming();
 #ifdef MYTHEN3D
 void setInitialExtSignals();
 int isMaster();
+int setGainCaps(int caps);
+int getGainCaps();
+int setChipStatusRegister(int csr);
+int setDACS(int* dacs);
 #endif
 #if defined(GOTTHARDD) || defined(MYTHEN3D)
 void setExtSignal(int signalIndex, enum externalSignalFlag mode);
--- a/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h
+++ b/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h
@ -246,4 +246,7 @@ int is_virtual(int);
 int get_pattern(int);
 int load_default_pattern(int);
 int get_all_threshold_energy(int);
-int get_master(int);
+int get_master(int);
+int get_csr();
+int set_gain_caps(int);
+int get_gain_caps(int);
--- a/slsDetectorServers/slsDetectorServer/src/loadPattern.c
+++ b/slsDetectorServers/slsDetectorServer/src/loadPattern.c
@ -0,0 +1,105 @@
+#include "readDefaultPattern.h"
+#include "loadPattern.h"
+#include "clogger.h"
+#include "common.h"
+#include "sls/ansi.h"
+#include "sls/sls_detector_defs.h"
+#include "slsDetectorServer_defs.h"
+
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(MYTHEN3D)
+#include "Pattern.h"
+#endif
+
+#include <string.h>
+#include <unistd.h>
+
+extern char initErrorMessage[MAX_STR_LENGTH];
+
+#ifndef MYTHEN3D
+extern uint64_t writePatternIOControl(uint64_t word);
+#endif
+extern uint64_t writePatternWord(int addr, uint64_t word);
+extern int setPatternWaitAddress(int level, int addr);
+extern uint64_t setPatternWaitTime(int level, uint64_t t);
+extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
+                           int *nLoop);
+
+int loadPattern(patternParameters *pat) {
+
+  int ret=OK;
+
+  for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
+    if ((i % 10 == 0) && pat->word[i] != 0) {
+      LOG(logINFO, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
+		    i, (long long int)pat->word[i]));
+    }
+    writePatternWord(i, pat->word[i]);
+  }
+#ifndef MYTHEN3D 
+   if (ret == OK) { 
+     uint64_t retval64 = writePatternIOControl(pat->ioctrl); 
+     //validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX); 
+   } 
+#endif 
+        if (ret == OK) {
+            int numLoops = -1;
+            int retval0 = pat->limits[0];
+            int retval1 = pat->limits[1];
+            setPatternLoop(-1, &retval0, &retval1, &numLoops);
+            //validate(pat->limits[0], retval0,
+	    // "set pattern Limits start address", HEX);
+	//validate(pat->limits[1], retval1,
+	    //       "set pattern Limits start address", HEX);
+        }
+	uint64_t retval64;
+        if (ret == OK) {
+            for (int i = 0; i <= 2; ++i) {
+                char msg[128];
+                int retval0 = -1, retval1 = -1, numLoops = -1;
+
+                // patloop
+                retval0 = pat->loop[i * 2 + 0];
+                retval1 = pat->loop[i * 2 + 1];
+                numLoops = pat->nloop[i];
+                setPatternLoop(i, &retval0, &retval1, &numLoops);
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d start address", i);
+                //validate(pat->loop[i * 2 + 0], retval0, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d stop address", i);
+                //validate(pat->loop[i * 2 + 1], retval1, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d num loops", i);
+                //validate(pat->nloop[i], numLoops, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                // patwait
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d wait address", i);
+                retval0 = setPatternWaitAddress(i, pat->wait[i]);
+                //validate(pat->wait[i], retval0, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+
+                // patwaittime
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d wait time", i);
+                retval64 = setPatternWaitTime(i, pat->waittime[i]);
+                //validate64(pat->waittime[i], retval64, msg, HEX);
+                if (retval64 == FAIL) {
+                    break;
+                }
+	    }
+	}
+	return ret;
+}
+
+
--- a/slsDetectorServers/slsDetectorServer/src/readDefaultPattern.c
+++ b/slsDetectorServers/slsDetectorServer/src/readDefaultPattern.c
@ -1,4 +1,5 @@
 #include "readDefaultPattern.h"
+#include "loadPattern.h"
 #include "clogger.h"
 #include "common.h"
 #include "sls/ansi.h"
--- a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
+++ b/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
@ -369,6 +369,9 @@ void function_table() {
    flist[F_LOAD_DEFAULT_PATTERN] = &load_default_pattern;
    flist[F_GET_ALL_THRESHOLD_ENERGY] = &get_all_threshold_energy;
    flist[F_GET_MASTER] = &get_master;
+    flist[F_GET_CSR] = &get_csr;
+    flist[F_SET_GAIN_CAPS] = &set_gain_caps;
+    flist[F_GET_GAIN_CAPS] = &get_gain_caps;

    // check
    if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
@ -1547,18 +1550,11 @@ int set_module(int file_des) {
    // only set
    else if (Server_VerifyLock() == OK) {
        // check index
+
+#if !(defined(EIGERD) || defined(MYTHEN3D))
+//TODO! Check if this is used for any detector
        switch (module.reg) {
-#ifdef EIGERD
-        case STANDARD:
-        case HIGHGAIN:
-        case LOWGAIN:
-        case VERYHIGHGAIN:
-        case VERYLOWGAIN:
-#elif MYTHEN3D
-        case STANDARD:
-        case FAST:
-        case HIGHGAIN:
-#elif JUNGFRAUD
+#ifdef JUNGFRAUD
        case DYNAMICGAIN:
        case DYNAMICHG0:
        case FIXGAIN1:
@ -1577,10 +1573,12 @@ int set_module(int file_des) {
            modeNotImplemented("Settings", (int)module.reg);
            break;
        }
-
+#endif
        ret = setModule(module, mess);
        enum detectorSettings retval = getSettings();
+#if !(defined(EIGERD) || defined(MYTHEN3D))
        validate(module.reg, (int)retval, "set module (settings)", DEC);
+#endif
        LOG(logDEBUG1, ("Settings: %d\n", retval));
    }
    free(myChan);
@ -7578,18 +7576,22 @@ int set_pattern(int file_des) {

    patternParameters *pat = malloc(sizeof(patternParameters));
    memset(pat, 0, sizeof(patternParameters));
-
-    // ignoring endianness for eiger
+      // ignoring endianness for eiger
    if (receiveData(file_des, pat, sizeof(patternParameters), INT32) < 0) {
        if (pat != NULL)
            free(pat);
        return printSocketReadError();
    }
-
+ 
    if (Server_VerifyLock() == OK) {
        LOG(logINFO, ("Setting Pattern from structure\n"));
        LOG(logINFO,
-            ("Setting Pattern Word (printing every 10 words that are not 0\n"));
+            ("Setting Pattern Word (printing every 10 words that are not 0\n"));   
+	/****************************************************************************************************************/
+	/* I SUGGEST TO VALIDATE THE VALUES HERE AND THEN WRITE THE PATTERN IN A SEPARATE FUNCTION WHICH COULD BE REUSED*/
+	/* added loadPattern.c/h - the same func could be reused also in readDefaultPattern                                  */
+	/***************************************************************************************************************/
+
        for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
            if ((i % 10 == 0) && pat->word[i] != 0) {
                LOG(logINFO, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
@ -7662,6 +7664,7 @@ int set_pattern(int file_des) {
                }
            }
        }
+	/******* DOWN TO HERE ***********/
    }
    if (pat != NULL)
        free(pat);
@ -8383,3 +8386,63 @@ int get_master(int file_des){
 #endif
    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
 }
+
+int get_csr(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+
+    LOG(logDEBUG1, ("Getting csr\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    retval = getChipStatusRegister();
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_gain_caps(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int arg = 0;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logINFO, ("Setting gain caps to: %u\n", arg));
+
+    int retval = -1;
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    if (Server_VerifyLock() == OK) {
+        setGainCaps(arg);
+        retval = getChipStatusRegister(); //TODO! fix 
+        LOG(logDEBUG1, ("gain caps retval: %u\n", retval));
+    }
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int get_gain_caps(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    // int arg = 0;
+
+    // if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+    //     return printSocketReadError();
+    LOG(logINFO, ("Getting gain caps\n"));
+
+    int retval = -1;
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    if (Server_VerifyLock() == OK) {
+        retval = getGainCaps();
+        LOG(logDEBUG1, ("Gain caps: %u\n", retval));
+    }
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
--- a/slsDetectorSoftware/include/sls/Detector.h
+++ b/slsDetectorSoftware/include/sls/Detector.h
@ -498,7 +498,7 @@ class Detector {

    /** Non blocking: Abort detector acquisition. Status changes to IDLE or
     * STOPPED. Goes to stop server. */
-    void stopDetector();
+    void stopDetector(Positions pos = {});

    /** IDLE, ERROR, WAITING, RUN_FINISHED, TRANSMITTING, RUNNING, STOPPED \n
     * Goes to stop server */
@ -1308,6 +1308,14 @@ class Detector {

    Result<bool> getMaster(Positions pos = {}) const;

+
+    //TODO! check if we really want to expose this !!!!!
+    Result<int> getChipStatusRegister(Positions pos = {}) const;
+
+    void setGainCaps(int caps, Positions pos = {});
+
+    Result<int> getGainCaps(Positions pos = {});
+
    ///@{

    /** @name CTB / Moench Specific */
@ -1729,4 +1737,4 @@ class Detector {
    void updateRxRateCorrections();
 };

-} // namespace sls
+} // namespace sls
--- a/slsDetectorSoftware/src/CmdParser.cpp
+++ b/slsDetectorSoftware/src/CmdParser.cpp
@ -55,6 +55,12 @@ void CmdParser::Parse(const std::string &s) {
        command_ = arguments_[0];
        arguments_.erase(begin(arguments_));
    }
+    //allow comma sep
+    for (auto& arg : arguments_){
+        if (arg.back() == ',')
+            arg.pop_back();
+    }
+
    DecodeIdAndPosition(command_.c_str());
 }

--- a/slsDetectorSoftware/src/CmdProxy.cpp
+++ b/slsDetectorSoftware/src/CmdProxy.cpp
@ -54,7 +54,7 @@ bool CmdProxy::ReplaceIfDepreciated(std::string &command) {
    if (d_it != depreciated_functions.end()) {
        LOG(logWARNING)
            << command
-            << " is depreciated and will be removed. Please migrate to: "
+            << " is deprecated and will be removed. Please migrate to: "
            << d_it->second;
        // insert old command into arguments (for dacs)
        if (d_it->second == "dac") {
@ -1981,6 +1981,43 @@ std::string CmdProxy::GateDelay(int action) {
    return os.str();
 }

+
+std::string CmdProxy::GainCaps(int action){
+    std::ostringstream os;
+    os << cmd << ' ';
+    if (action == defs::HELP_ACTION) {
+        os << "[cap1, cap2, ...]\n\t[Mythen3] gain, options: C10pre, C15sh, C30sh, C50sh, C225ACsh, C15pre"
+           << '\n';
+    } else if (action == defs::GET_ACTION) {
+        if (!args.empty())
+            WrongNumberOfParameters(0);
+
+        auto tmp = det->getGainCaps();
+        sls::Result<defs::M3_GainCaps> csr;
+        for (auto val : tmp){
+            if (val)
+                csr.push_back(static_cast<defs::M3_GainCaps>(val));
+        }
+            
+        os << OutString(csr) << '\n';
+    } else if (action == defs::PUT_ACTION) {
+        if (args.size() < 1) {
+            WrongNumberOfParameters(1);
+        }
+        int caps = 0;
+        for (const auto& arg:args){
+            if (arg != "0")
+                caps |= sls::StringTo<defs::M3_GainCaps>(arg);
+        }
+            
+        det->setGainCaps(caps);
+        os << OutString(args) << '\n';
+    } else {
+        throw sls::RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
 /* CTB / Moench Specific */

 std::string CmdProxy::Samples(int action) {
--- a/slsDetectorSoftware/src/CmdProxy.h
+++ b/slsDetectorSoftware/src/CmdProxy.h
@ -571,19 +571,6 @@ class CmdProxy {
        return ToString(value, unit);
    }

-    // inline unsigned int stoiHex(const std::string& s) {
-    //     unsigned long lresult = stoul(s, nullptr, 16);
-    //     unsigned int result = lresult;
-    //     if (result != lresult) {
-    //         throw std::out_of_range("cannot convert to unsigned int");
-    //     }
-    //     return result;
-    // }
-
-    // inline unsigned long int stoulHex(const std::string& s) {
-    //     unsigned long result = stoul(s, nullptr, 16);
-    //     return result;
-    // }

    using FunctionMap = std::map<std::string, std::string (CmdProxy::*)(int)>;
    using StringMap = std::map<std::string, std::string>;
@ -970,6 +957,7 @@ class CmdProxy {
        {"gatedelay1", &CmdProxy::GateDelay},
        {"gatedelay2", &CmdProxy::GateDelay},
        {"gatedelay3", &CmdProxy::GateDelay},
+        {"gaincaps", &CmdProxy::GainCaps},

        /* CTB/ Moench Specific */
        {"samples", &CmdProxy::Samples},
@ -1137,6 +1125,7 @@ class CmdProxy {
    /* Mythen3 Specific */
    std::string Counters(int action);
    std::string GateDelay(int action);
+    std::string GainCaps(int action);
    /* CTB/ Moench Specific */
    std::string Samples(int action);
    /* CTB Specific */
@ -1455,7 +1444,7 @@ class CmdProxy {
        "\n\t[Mythen3] Starts detector readout. Status changes to TRANSMITTING "
        "and automatically returns to idle at the end of readout.");

-    EXECUTE_SET_COMMAND_NOID(stop, stopDetector,
+    EXECUTE_SET_COMMAND(stop, stopDetector,
                             "\n\tAbort detector acquisition. Status changes "
                             "to IDLE or STOPPED. Goes to stop server.");

--- a/slsDetectorSoftware/src/Detector.cpp
+++ b/slsDetectorSoftware/src/Detector.cpp
@ -675,7 +675,7 @@ void Detector::stopReceiver() { pimpl->Parallel(&Module::stopReceiver, {}); }

 void Detector::startDetector() {
    auto detector_type = getDetectorType().squash();
-    if (detector_type == defs::MYTHEN3){
+    if (detector_type == defs::MYTHEN3 && size() > 1){
        auto is_master = getMaster();
        std::vector<int> master;
        std::vector<int> slaves;
@ -697,7 +697,7 @@ void Detector::startDetectorReadout() {
    pimpl->Parallel(&Module::startReadout, {});
 }

-void Detector::stopDetector() { pimpl->Parallel(&Module::stopAcquisition, {}); }
+void Detector::stopDetector(Positions pos) { pimpl->Parallel(&Module::stopAcquisition, pos); }

 Result<defs::runStatus> Detector::getDetectorStatus(Positions pos) const {
    return pimpl->Parallel(&Module::getRunStatus, pos);
@ -1615,6 +1615,18 @@ Result<bool> Detector::getMaster(Positions pos) const{
    return pimpl->Parallel(&Module::isMaster, pos);
 }

+Result<int> Detector::getChipStatusRegister(Positions pos) const{
+    return pimpl->Parallel(&Module::getChipStatusRegister, pos);
+}
+
+void Detector::setGainCaps(int caps, Positions pos){
+    return pimpl->Parallel(&Module::setGainCaps, pos, caps);
+}
+
+Result<int> Detector::getGainCaps(Positions pos){
+    return pimpl->Parallel(&Module::getGainCaps, pos);
+}
+

 // CTB/ Moench Specific

@ -2092,4 +2104,4 @@ std::vector<int> Detector::getPortNumbers(int start_port) {
    return res;
 }

-} // namespace sls
+} // namespace sls
--- a/slsDetectorSoftware/src/Module.cpp
+++ b/slsDetectorSoftware/src/Module.cpp
@ -412,7 +412,7 @@ void Module::loadSettingsFile(const std::string &fname) {
        if (shm()->myDetectorType == MYTHEN3) {
            serialNumberWidth = 4;
        }
-        if (fname.find(".sn") == std::string::npos) {
+        if ((fname.find(".sn") == std::string::npos) && (fname.find(".trim") == std::string::npos)) {
            ostfn << ".sn" << std::setfill('0') << std::setw(serialNumberWidth)
                  << std::dec << getSerialNumber();
        }
@ -1998,6 +1998,18 @@ bool Module::isMaster() const{
    return sendToDetector<int>(F_GET_MASTER);
 }

+int Module::getChipStatusRegister() const{
+    return sendToDetector<int>(F_GET_CSR);
+}
+
+void Module::setGainCaps(int caps){
+    sendToDetector<int>(F_SET_GAIN_CAPS, caps);
+}
+
+int Module::getGainCaps(){
+    return sendToDetector<int>(F_GET_GAIN_CAPS);
+}
+
 // CTB / Moench Specific
 int Module::getNumberOfAnalogSamples() const {
    return sendToDetector<int>(F_GET_NUM_ANALOG_SAMPLES);
@ -3195,6 +3207,9 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
        throw RuntimeError("Could not open settings file: " + fname);
    }

+    auto file_size = getFileSize(infile);
+
+
    // eiger
    if (shm()->myDetectorType == EIGER) {
        infile.read(reinterpret_cast<char *>(myMod.dacs),
@ -3220,6 +3235,16 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,

    // mythen3 (dacs, trimbits)
    else if (shm()->myDetectorType == MYTHEN3) {
+        int expected_size =
+            sizeof(int) * myMod.ndac + sizeof(int) * myMod.nchan + sizeof(myMod.reg);
+        if (file_size != expected_size) {
+            throw RuntimeError("The size of the settings file: " + fname +
+                               " differs from the expected size, " +
+                               std::to_string(file_size) + " instead of " +
+                               std::to_string(expected_size) + " bytes");
+        }
+        infile.read(reinterpret_cast<char *>(&myMod.reg),
+                    sizeof(myMod.reg));
        infile.read(reinterpret_cast<char *>(myMod.dacs),
                    sizeof(int) * (myMod.ndac));
        for (int i = 0; i < myMod.ndac; ++i) {
--- a/slsDetectorSoftware/src/Module.h
+++ b/slsDetectorSoftware/src/Module.h
@ -426,6 +426,9 @@ class Module : public virtual slsDetectorDefs {
    void setGateDelay(int gateIndex, int64_t value);
    std::array<time::ns, 3> getGateDelayForAllGates() const;
    bool isMaster() const;
+    int getChipStatusRegister() const;
+    void setGainCaps(int caps);
+    int getGainCaps();

    /**************************************************
     *                                                *
--- a/slsSupportLib/CMakeLists.txt
+++ b/slsSupportLib/CMakeLists.txt
@ -57,14 +57,12 @@ target_include_directories(slsSupportObject
  PUBLIC
    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
-  PRIVATE
-    ${ZeroMQ_INCLUDE_DIRS}
 )

 target_link_libraries(slsSupportObject 
  PUBLIC
    slsProjectOptions 
-    ${ZeroMQ_LIBRARIES}
+    libzmq
    rapidjson
  PRIVATE
    slsProjectWarnings     
@ -76,7 +74,6 @@ endif(SLS_USE_TESTS)

 # Add shared library version of the support lib
 add_library(slsSupportShared SHARED $<TARGET_OBJECTS:slsSupportObject>)
-
 target_link_libraries(slsSupportShared PUBLIC slsSupportObject)

 set_target_properties(slsSupportShared PROPERTIES
@ -108,3 +105,4 @@ install(TARGETS slsSupportShared slsSupportStatic slsSupportObject
    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sls
 )

+
--- a/slsSupportLib/include/sls/ToString.h
+++ b/slsSupportLib/include/sls/ToString.h
@ -36,6 +36,7 @@ std::string ToString(const defs::dacIndex s);
 std::string ToString(const std::vector<defs::dacIndex> &vec);
 std::string ToString(const defs::burstMode s);
 std::string ToString(const defs::timingSourceType s);
+std::string ToString(const defs::M3_GainCaps s);

 std::string ToString(const slsDetectorDefs::xy &coord);
 std::ostream &operator<<(std::ostream &os, const slsDetectorDefs::xy &coord);
@ -297,6 +298,7 @@ template <> defs::readoutMode StringTo(const std::string &s);
 template <> defs::dacIndex StringTo(const std::string &s);
 template <> defs::burstMode StringTo(const std::string &s);
 template <> defs::timingSourceType StringTo(const std::string &s);
+template <> defs::M3_GainCaps StringTo(const std::string &s);

 template <> uint32_t StringTo(const std::string &s);
 template <> uint64_t StringTo(const std::string &s);
--- a/slsSupportLib/include/sls/file_utils.h
+++ b/slsSupportLib/include/sls/file_utils.h
@ -48,3 +48,7 @@ int writeDataFile(std::string fname, int nch, short int *data);

 // mkdir -p path implemented by recursive calls
 void mkdir_p(const std::string &path, std::string dir = "");
+
+namespace sls {
+int getFileSize(std::ifstream &ifs);
+}
--- a/slsSupportLib/include/sls/sls_detector_defs.h
+++ b/slsSupportLib/include/sls/sls_detector_defs.h
@ -394,6 +394,16 @@ typedef struct {
     */
    enum timingSourceType { TIMING_INTERNAL, TIMING_EXTERNAL };

+    //gain caps Mythen3
+    enum M3_GainCaps {
+        M3_C10pre= 1<<7, 
+        M3_C15sh = 1<<10, 
+        M3_C30sh = 1<<11,
+        M3_C50sh = 1<<12,
+        M3_C225ACsh = 1<<13,
+        M3_C15pre = 1<<14, 
+    };
+
 #ifdef __cplusplus

    /** scan structure */
@ -625,6 +635,10 @@ typedef struct {
 #endif

 #ifdef __cplusplus
+
+
+
+
 // TODO! discuss this
 #include <vector> //hmm... but currently no way around
 namespace sls {
--- a/slsSupportLib/include/sls/sls_detector_funcs.h
+++ b/slsSupportLib/include/sls/sls_detector_funcs.h
@ -221,6 +221,9 @@ enum detFuncs {
    F_LOAD_DEFAULT_PATTERN,
    F_GET_ALL_THRESHOLD_ENERGY,
    F_GET_MASTER,
+    F_GET_CSR,
+    F_SET_GAIN_CAPS,
+    F_GET_GAIN_CAPS,

    NUM_DET_FUNCTIONS,
    RECEIVER_ENUM_START = 256, /**< detector function should not exceed this
--- a/slsSupportLib/include/sls/versionAPI.h
+++ b/slsSupportLib/include/sls/versionAPI.h
@ -1,12 +1,12 @@
 /** API versions */
 #define GITBRANCH    "developer"
-#define APILIB 0x201119
-#define APIRECEIVER 0x201119
-#define APIGUI 0x201119
-#define APICTB 0x201214
-#define APIGOTTHARD 0x201214
-#define APIGOTTHARD2 0x201214
-#define APIJUNGFRAU 0x201214
-#define APIMOENCH 0x201214
-#define APIEIGER 0x201214
-#define APIMYTHEN3 0x201214
+#define APICTB 0x210225
+#define APIGOTTHARD 0x210225
+#define APIGOTTHARD2 0x210225
+#define APIJUNGFRAU 0x210225
+#define APIMOENCH 0x210225
+#define APIEIGER 0x210225
+#define APIMYTHEN3 0x210225
+#define APILIB 0x210225
+#define APIRECEIVER 0x210225
+#define APIGUI 0x210225
--- a/slsSupportLib/src/ToString.cpp
+++ b/slsSupportLib/src/ToString.cpp
@ -859,6 +859,44 @@ template <> defs::timingSourceType StringTo(const std::string &s) {
    throw sls::RuntimeError("Unknown timing source type " + s);
 }

+template <> defs::M3_GainCaps StringTo(const std::string &s){
+    if (s == "C10pre")
+        return defs::M3_C10pre;
+    if (s == "C15sh")
+        return defs::M3_C15sh;
+    if (s == "C30sh")
+        return defs::M3_C30sh;
+    if (s == "C50sh")
+        return defs::M3_C50sh;
+    if (s == "C225ACsh")
+        return defs::M3_C225ACsh;
+    if (s == "C15pre")
+        return defs::M3_C15pre;
+    throw sls::RuntimeError("Unknown gain cap " + s);
+    
+}
+
+
+std::string ToString(defs::M3_GainCaps s){
+    std::ostringstream os; 
+    if (s & defs::M3_C10pre)
+        os << "C10pre, ";
+    if (s & defs::M3_C15sh)
+        os << "C15sh, ";
+    if (s & defs::M3_C30sh)
+        os << "C30sh, ";
+    if (s & defs::M3_C50sh)
+        os << "C50sh, ";
+    if (s & defs::M3_C225ACsh)
+        os << "C225ACsh, ";
+    if (s & defs::M3_C15pre)
+        os << "C15pre, ";
+    auto rs = os.str();
+    rs.erase(rs.end()-2);
+    return rs;
+    
+}
+
 template <> uint32_t StringTo(const std::string &s) {
    int base = s.find("0x") != std::string::npos ? 16 : 10;
    return std::stoul(s, nullptr, base);
--- a/slsSupportLib/src/file_utils.cpp
+++ b/slsSupportLib/src/file_utils.cpp
@ -3,6 +3,7 @@
 #include "sls/sls_detector_exceptions.h"

 #include <errno.h>
+#include <ios>
 #include <iostream>
 #include <sstream>
 #include <sys/stat.h>
@ -92,3 +93,13 @@ void mkdir_p(const std::string &path, std::string dir) {
    if (i + 1 < path.length())
        mkdir_p(path.substr(i + 1), dir);
 }
+
+namespace sls {
+int getFileSize(std::ifstream &ifs) {
+    auto current_pos = ifs.tellg();
+    ifs.seekg(0, std::ios::end);
+    int file_size = ifs.tellg();
+    ifs.seekg(current_pos);
+    return file_size;
+}
+} // namespace sls
--- a/slsSupportLib/tests/CMakeLists.txt
+++ b/slsSupportLib/tests/CMakeLists.txt
@ -1,5 +1,6 @@
 target_sources(tests PRIVATE 
                ${CMAKE_CURRENT_SOURCE_DIR}/test-bit_utils.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-file_utils.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test-container_utils.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test-network_utils.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test-string_utils.cpp
--- a/slsSupportLib/tests/test-file_utils.cpp
+++ b/slsSupportLib/tests/test-file_utils.cpp
@ -0,0 +1,28 @@
+#include "catch.hpp"
+#include "sls/file_utils.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <iostream>
+#include <vector>
+
+TEST_CASE("Get size of empty file") {
+    char fname[] = "temfile_XXXXXX";
+    int fh = mkstemp(fname);
+    std::ifstream ifs(fname);
+    auto size = sls::getFileSize(ifs);
+    REQUIRE(size == 0);
+}
+
+TEST_CASE("Get size of file with data") {
+    constexpr size_t n_bytes = 137;
+    std::vector<char> data(n_bytes);
+    char fname[] = "temfile_XXXXXX";
+    int fh = mkstemp(fname);
+    write(fh, data.data(), n_bytes);
+
+    std::ifstream ifs(fname);
+    auto size = sls::getFileSize(ifs);
+    REQUIRE(size == n_bytes);
+    REQUIRE(ifs.tellg() == 0); //getting size resets pos!
+}
+
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@ -18,22 +18,24 @@ set_target_properties(testserver PROPERTIES
    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
    
 add_executable(tests ${SLS_TEST_SOURCES})
-target_link_libraries(tests 
-    slsProjectOptions
-    slsProjectWarnings
-    slsSupportShared
-    pthread
-    rt
+target_link_libraries(tests
+    PUBLIC 
+      slsProjectOptions
+      slsSupportShared
+      pthread
+      rt
+    PRIVATE
+      slsProjectWarnings
 )  

 if (SLS_USE_TEXTCLIENT)
-    target_link_libraries(tests
+    target_link_libraries(tests PUBLIC
        slsDetectorShared
    )
 endif (SLS_USE_TEXTCLIENT)

 if (SLS_USE_RECEIVER)
-    target_link_libraries(tests
+    target_link_libraries(tests PUBLIC
        slsReceiverShared
    )
 endif (SLS_USE_RECEIVER)
Author	SHA1	Message	Date
Erik Frojdh	085ea3aee7	dont add detector id for .trim	2021-04-27 08:28:05 +02:00
Erik Frojdh	c054ad3af3	Merge branch 'my3regs' into developer	2021-04-26 08:39:46 +02:00
Erik Frojdh	28c7d533e9	fixed compile defs for moench zmq	2021-04-22 08:29:15 +02:00
Anna Bergamaschi	fa6a685508	fixed moenchZmq executables	2021-04-21 17:25:51 +02:00
brueckner_m	d5c10aa3e7	stop command: Support single (half)module stop	2021-04-21 15:40:51 +02:00
Erik Frojdh	be5fee8126	M3: fixed gain bits with negative polarity	2021-04-12 16:44:47 +02:00
Erik Frojdh	d9cd780386	p gaincap 0	2021-04-12 13:31:10 +02:00
Erik Frojdh	55b4a92453	using setChipStatusRegister	2021-04-07 16:27:40 +02:00
Erik Frojdh	0299d315d5	added command line option	2021-04-01 10:06:37 +02:00
Erik Frojdh	779a2a0199	CSR in trim files	2021-04-01 08:09:04 +02:00
Erik Frojdh	01c785271f	WIP	2021-03-31 16:26:36 +02:00
Erik Frojdh	05ddc5caaf	pybind11 back to 2.6.2	2021-03-29 17:02:00 +02:00
Erik Frojdh	fa25340e5c	allow bitwise op on the gain cap	2021-03-29 16:14:10 +02:00
Anna Bergamaschi	e65e7ac42f	energyCalibration updated with Sophie's version	2021-03-29 15:35:27 +02:00
Erik Frojdh	7d605c2c87	names	2021-03-29 14:50:08 +02:00
Erik Frojdh	043d582616	initial implementation	2021-03-29 14:21:48 +02:00
Erik Frojdh	7c4f9ee044	read back of csr	2021-03-26 17:46:11 +01:00
Erik Frojdh	a2007b78e7	updated pybind also for my3regs	2021-03-23 11:48:35 +01:00
Erik Frojdh	7004f43a9a	Merge branch 'developer' into my3regs	2021-03-23 11:44:52 +01:00
Erik Frojdh	2b3b5af303	report developer as version	2021-03-23 11:44:25 +01:00
Erik Frojdh	7a67d7e88a	minor cmake and servers now reflect developer	2021-03-23 10:54:01 +01:00
Erik Frojdh	60e3fb8aab	fixing conflics after merging back release to developer	2021-03-23 10:50:09 +01:00
Erik Fröjdh	2f2fe4dd47	Release of 5.1.0 (#237 ) * Setting pattern from memory (#218) * ToString accepts c-style arrays * fixed patwait time bug in validation * Introduced pattern class * compile for servers too * Python binding for Pattern * added scanParameters in Python * slsReceiver: avoid potential memory leak around Implementation::generalData * additional constructors for scanPrameters in python * bugfix: avoid potentital memory leak in receiver if called outside constructor context * added scanParameters in Python * additional constructors for scanPrameters in python * M3defaultpattern (#227) * default pattern for m3 and moench including Python bindings * M3settings (#228) * some changes to compile on RH7 and in the server to load the default chip status register at startup * Updated mythen3DeectorServer_developer executable with correct initialization at startup Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com> Co-authored-by: Anna Bergamaschi <anna.bergamaschi@psi.ch> * Pattern.h as a public header files (#229) * fixed buffer overflow but caused by using global instead of local enum * replacing out of range trimbits with edge values * replacing dac values that are out of range after interpolation * updated pybind11 to 2.6.2 * Mythen3 improved synchronization (#231) Disabling scans for multi module Mythen3, since there is no feedback of the detectors being ready startDetector first starts the slaves then the master acquire firs calls startDetector for the slaves then acquire on the master getMaster to read back from hardware which one is master * New server for JF to go with the new FW (#232) * Modified Jungfrau speed settings for HW1.0 - FW fix version 1.1.1, compilation date 210218 * Corrected bug. DBIT clk phase is implemented in both HW version 1.0 and 2.0. Previous version did not update the DBIT phase shift on the configuration of a speed. * fix for m3 scan with single module * m3 fw version * m3 server * bugfix for bottom when setting quad * new strategy for finding zmq based on cppzmq Co-authored-by: Dhanya Thattil <dhanya.thattil@psi.ch> Co-authored-by: Dhanya Thattil <33750417+thattil@users.noreply.github.com> Co-authored-by: Alejandro Homs Puron <ahoms@esrf.fr> Co-authored-by: Anna Bergamaschi <anna.bergamaschi@psi.ch> Co-authored-by: Xiaoqiang Wang <xiaoqiangwang@gmail.com> Co-authored-by: lopez_c <carlos.lopez-cuenca@psi.ch>	2021-03-22 14:43:11 +01:00
Anna Bergamaschi	7955426682	my3: added function to change the gain + some functions for my3 flags added	2021-02-26 18:02:48 +01:00
Anna Bergamaschi	63259ec5c8	Modified my3 functions for the pattern generator and moved to separate file; created loadPattern function - but should still be used in readDefaultPattern	2021-02-26 16:53:30 +01:00